All Classes and Interfaces
Class
Description
Abstract
BackupRepository implementation providing some logic shared between real
implementations.Base class that can be extended by any
UpdateRequestProcessorFactory designed to add
a default value to the document in an AddUpdateCommand when that field is not
already specified.Abstract Field type for support of string values with custom sort order.
Models all the info contained in an enums config XML file
Abstract base class for all Lucene-based spell checking implementations.
Abstract base class for numeric range field types that wrap Lucene's multi-dimensional range
fields (e.g.,
IntRange, LongRange).Marker interface for parsed range value objects.
An abstract super class that manages standard solr-style plugin configuration.
Abstract base class for Solr FieldTypes based on a Lucene 4
SpatialStrategy.Abstract provider with default implementation
An abstract base class for FieldTypes that delegate work to another
FieldType.Watch for replicas to become
Replica.State.ACTIVE.List the active tasks that can be cancelled
Handles request for listing all active cancellable tasks
A data structure to keep all information required to create a new replica in one place.
V2 API for adding a property to a collection replica
Simple utilities for working Hostname/IP Addresses
This processor will dynamically add fields to the schema if an input document contains one or
more fields that don't match any field or dynamic field in the schema.
An
UpdateCommand for adding or updating one document.A common parent for "admin" (i.e.
Static methods to proxy calls to an Admin (GET) API to other nodes in the cluster and return a
combined response
Configuration bean for
AffinityPlacementFactory.This factory is instantiated by config from its class name.
See
AffinityPlacementFactory for instructions on how to configure a cluster to use this
plugin and details on what the plugin does.Aggregate stats from multiple
ShardBackupMetadataThis class is used for keeping several partial named values and providing useful statistics over
them.
Simple class to represent current value and how many times it was set.
V2 APIs for managing and inspecting properties for collection aliases
V2 API for retrieving status information for all cores on the receiving node.
Validates URLs based on an allow list or a
ClusterState in SolrCloud.Validates a caller-supplied ZooKeeper connection string against the local cluster's ensemble and
a configured allow-list.
Abstract subclass of FieldMutatingUpdateProcessor for implementing UpdateProcessors that will
mutate all individual values of a selected field independently.
This is an alternative implementation of
BufferPoolMetricSet
that doesn't need an MBean server.A base class for all analysis request handlers.
Serves as the context of an analysis process.
TokenStream that iterates over a list of pre-existing Tokens
This is an
Attribute used to track the positions of tokens in the analysis chain.Implementation of
AnalysisRequestHandlerBase.TokenTrackingAttribute.Note: This API is experimental and may change in non backward-compatible ways in the
future
Factory for
AnalyzingInfixSuggesterFactory for
AnalyzingSuggesterThis class implements an Api just from an annotated java class The class must have an annotation
EndPoint Each method must have an annotation Command The methods that implement a
command should have the first 2 parameters SolrQueryRequest and SolrQueryResponse
or it may optionally have a third parameter which could be a java class annotated with jackson
annotations.Every version 2 API must extend the this class.
Interface to be implemented by the Request Handlers that need to provide some custom
configuration to the V2 APIs
Jersey binder for APIConfigProvider
The interface that is implemented by a request handler to support the V2 end point
Asserts various conditions and exists with error code if fails, else continues with no output
Thrown if there is an exception while assigning nodes for replicas
Strategy for assigning replicas to nodes.
An update processor that will convert conventional field-value document to atomic update document
Instances of this interface are used to fetch various attributes from nodes (and other sources)
in the cluster.
Implementation of
AttributeFetcher that uses SolrCloudManager to access Solr
cluster details.Implementation of
AttributeValues used by AttributeFetcherImpl.Audit event that takes request and auth context as input to be able to audit log custom things.
Base class for Audit logger plugins.
Interface for formatting the event
Event formatter that returns event as JSON string
Request context for Solr to be used by Authorization plugin.
Authorization interface that needs to be implemented to write an authorization plugin.
Base class that facilitates reuse of common validation logic for collection-backup APIs.
Utility class for getting paths related to backups, or parsing information out of those paths.
Represents the ID of a particular backup.
This class implements functionality to create a backup with extension points provided to
integrate with different types of file-systems.
Represents a backup[-*].properties file, responsible for holding whole-collection and
whole-backup metadata.
This interface defines the functionality required to backup/restore Solr indexes to an arbitrary
storage system.
This enumeration defines the type of a given path.
A fully specified plan or instructions for replica balancing to be applied to the cluster.
Allows plugins to create
BalancePlans telling the Solr layer how to balance replicas
following the processing of a BalanceRequest.Simple implementation of
BalancePlanFactory.V2 API for balancing the replicas that already exist across a set of nodes.
A cluster related placement request that Solr asks a
PlacementPlugin to resolve and
compute replica balancing plan for replicas that already exist across a set of Nodes.V2 API implementation for insuring that a particular property is distributed evenly amongst the
physical nodes comprising a collection.
This is a utility class to provide an easy mapping of request handlers which support multiple
commands to the V2 API format (core admin api, collections api).
Abstract based class for implementing TokenFilterFactory objects that are managed by the REST
API.
Base class for delegating REST-oriented requests to ManagedResources.
Deprecated.
Implementations of
BinaryQueryResponseWriter are used to write response in binary
format.A
FixedBitSet based implementation of a DocSet.Factory for
BlendedInfixLookupFactoryDeprecated.
The purpose of this class is to store the Jars loaded in memory and to keep only one copy of the
Jar in a single node.
Matches child documents based on parent doc criteria.
Usage: {!child of="PARENT:true"}PARENT_PRICE:10
Matches parent documents based on child doc criteria.
Usage: {!parent which="PARENT:true"}CHILD_PRICE:10 supports optional
score parameter
with one of ScoreMode values: None,Avg,Total,Min,Max.Factory for BM25Similarity.
Factory for
BooleanSimilarityCreate a boolean query from sub queries.
Create a boosted query from the input value.
A TreeSet that ensures it never grows beyond a max size.
A
MergePolicyFactory for BPReorderingMergePolicy objects.Factory to instantiate
ByteBuffersDirectoryContains the knowledge of how cache config is stored in the solrconfig.xml file, and implements a
factory to create caches.
Implementations of
CacheRegenerator are used in autowarming to populate a new cache
based on an old cache.A
DirectoryFactory impl base class for caching Directory instances per path.Delegates to a filtered or unwrapped directory, and allows this caching factory to release
correctly the corresponding cached directory.
A SolrCache backed by the Caffeine caching library [1].
Allows a query to be cancelled
Thrown when a query gets cancelled
Tracks metadata for active queries and provides methods for access
V2 API for cancelling a currently running "task".
Flattens the exception and sets on a
SolrJerseyResponse.This class can load a single document or a stream of documents in CBOR format this is equivalent
of loading a single json documet or an array of json documents
A response writer impl that can write results in CBOR (cbor.io) format when wt=cbor.
An authentication plugin that sets principal based on the certificate subject
Defines the interface for resolving a
Principal from an X509 certificate.Represents a pattern for resolving certificate information, specifying the criteria for
extracting and matching values from certificates.
Enum defining the types of checks that can be performed on extracted certificate values.
Utility class for certificate-related operations, including extracting fields from the subject or
issuer DN and SAN fields from X509 certificates.
Supported SAN (Subject Alternative Name) types as defined in RFC 5280
A simple StringBuffer replacement that aims to reduce copying as much as possible.
Represents checksum information for an index file being backed up.
Attaches all descendants (child documents) to each parent document.
Default base class to define circuit breaker plugins for Solr.
Deprecated.
Use individual Circuit Breakers instead
Keeps track of all registered circuit breaker instances for various request types.
FIFO Circular List.
Factory for
ClassicSimilarityThis class implements an UpdateProcessorFactory for the Classification Update Processor.
The classify expression retrieves a model trained by the train expression and uses it to classify
documents from a stream Syntax: classif(model(...), anyStream(...), field="body")
V2 API implementation for ConfigsetsApi.Clone
Clones the values found in any matching
source field into a configured dest
field.Used to request notification when the core is closed.
SolrCloud metadata attached to a
CoreDescriptor.A representation of the SolrCloud cluster state, providing information on which nodes and
collections are part of the cluster and a way to get to more detailed info.
All V2 APIs that have a prefix of /api/cluster/
Cluster-level event.
Components that want to be notified of cluster-wide events should use this.
Component that produces
ClusterEvent instances.Base class for implementing
ClusterEventProducer.This class helps in handling the initial registration of plugin-based listeners, when both the
final
ClusterEventProducer implementation and listeners are configured using plugins.A source for Cluster Plugin configurations
Event generated when
ZkStateReader.CLUSTER_PROPS is
modified.Intended for components that should be enabled only one instance per cluster.
Helper class to manage the initial registration of
ClusterSingleton plugins and to track
the changes in loaded plugins in ContainerPluginsRegistry.Shard / collection health state.
Supports cluster command in the bin/solr script.
Factory for plugging in a custom
CodecThis class contains "smaller" Collection API commands implementation, the interface implemented
by all commands and the class mapping a collection action to the actual command.
Interface implemented by all Collection API commands.
Map
CollectionParams.CollectionAction to instances of
CollApiCmds.CollectionApiCommand and being usable by both OverseerCollectionMessageHandler and DistributedCollectionConfigSetCommandRunner so
that the mappings do not have to be maintained in two places.The CollapsingQParserPlugin is a PostFilter that performs field collapsing.
Models all the information about how group head documents should be selected
Field for collated sort keys.
This class implements a higher level locking abstraction for the Collection API using lower level
read and write locks.
Data passed to Collection API command execution, to allow calls from either the
OverseerCollectionMessageHandler when commands are executed on the Overseer, or - in a future
change - allow Collection API commands to be executed in a distributed way, unrelated to and not
depending upon Overseer abstractions (including overseer collection message handling).This class contains helper methods used by commands of the Collection API.
Collection-level metrics.
Builder class for constructing instances of
CollectionMetrics.V2 API implementations for managing collection-level properties.
Event generated when some collections have been added.
This class defines the meta-data about a collection level snapshot
Event generated when some collections have been removed.
This is an illustration how to re-implement the combination of Solr 8x NodeLostTrigger and
AutoAddReplicasPlanAction to maintain the collection's replicas when nodes are lost.
Modifiable version of
CollectionStatistics useful for aggregation of per-shard stats.V2 API implementation for
CollectionStatusApi.Report low-level details of collection.
Extends QueryComponent with support for executing multiple queries and combining their results,
like hybrid search with RFF.
Extends the SearchHandler combining/fusing multiple queries (e.g.
Defines a grouping command.
Responsible for executing a search with a number of
Command instances.Helper class for tracking autoCommit state.
A commit index command encapsulated in an object.
Parse Solr's variant on the Lucene
ComplexPhraseQueryParser syntax.Concatenates multiple values for fields matching the specified conditions using a configurable
delimiter which defaults to ", ".ConcatStringFunction concatenates the string values of its components in the order
given.A LRU cache implementation based upon ConcurrentHashMap and other techniques to reduce contention
and synchronization overhead to utilize multiple CPU cores more effectively.
An interface to be implemented by a Plugin whose Configuration is runtime editable
This class encapsulates the config overlay json file.
Stores a core's configuration in the form of a SolrConfig and IndexSchema.
Parent class for all APIs that manipulate configsets
This class implements a higher level locking abstraction for the Config Set API using lower level
read and write locks.
This class contains methods dealing with Config Sets and called for Config Set API execution,
called from the
OverseerConfigSetMessageHandler or from DistributedCollectionConfigSetCommandRunner.runConfigSetCommand(org.apache.solr.response.SolrQueryResponse, org.apache.solr.common.params.ConfigSetParams.ConfigSetAction, java.util.Map<java.lang.String, java.lang.Object>, long)
depending on whether Collection and Config Set APIs are Overseer based or distributed.Utility methods for reading configSet properties.
Service class used by the CoreContainer to load ConfigSets for use in SolrCore creation.
A
SolrRequestHandler for ConfigSets API requests.Sends a POST to the Config API to perform a specified action.
Implement this interface if your plugin needs to accept some configuration
This class lets a query be run through multiple spell checkers.
constants used in facets package
API to maintain container-level plugin configurations.
This class manages the container-level plugins and their Api-s.
Listener for notifications about added / deleted / modified plugins.
Utility methods for creating and populating a
ContainerRequest for use with Jersey ApplicationHandlersAn implementation of
UpdateRequestProcessor which computes a hash of field values, and
uses this hash to reject/accept document updates.Factory for
ContentHashVersionProcessor instances.Shares common code between various handlers that manipulate
ContentStream objects.Load a
ContentStream into SolrA CoordinateFieldType is the base class for
FieldTypes that have
semantics related to items in a coordinate system.A coordinator node can serve requests as if it hosts all collections in the cluster.
CopyField contains all the information of a valid copy fields in an index.A common parent for admin Core Jersey-based APIs.
Helper RuntimeException to allow passing checked exceptions to the caller of the handle method.
Helper class to manage the tasks to be tracked.
A service that can provide access to solr cores.
Metadata about a
SolrCore.Persists CoreDescriptors as properties files
V2 API implementation of
ReplicationApisManage the discovery and persistence of core definitions across Solr restarts
V2 API for Creating, Listing, and Deleting Core Snapshots.
This is a utility class that sorts cores in such a way as to minimize other cores waiting for
replicas in the current node.
Replaces any list of values for a field matching the specified conditions with the count of the
number of values for that field.
AggValueSource to count values for given ValueSourceEnforces a CPU-time based timeout on a given SolrQueryRequest, as specified by the
cpuAllowed query parameter.Tracks current CPU usage and triggers if the specified threshold is breached.
V2 API for creating an alias
V2 API for creating a SolrCLoud collection
V2 API for creating a new "backup" of a specified collection
V2 API implementation for creating a collection-level snapshot.
V2 API for creating a new core on the receiving node.
V2 API implementation for adding a new replica to an existing shard.
V2 API for creating a new shard in a collection.
This class implements the functionality of creating a collection level snapshot.
Supports create command in the bin/solr script.
A utility class with helpers for various signature and certificate tasks
Parses CSV files according to the specified configuration.
Print values as a comma separated list.
Response writer for csv data
CSVStrategy
Utility methods for dealing with CSV files
Deprecated.
Field type for support of monetary values.
Represents a Currency field value, which includes a long amount and ISO currency code.
An object that encapsulates the basic information about the current Mark Point of a "Cursor"
based request.
ConfigNode impl that applies property substitutions on access.
A Simple Utility class for parsing "math" like strings relating to Dates.
FieldType that can represent any Date/Time with millisecond precision.
A field for indexed dates and date ranges.
Marker interface for Date-valued field types.
Adds debugging information to a request.
Implementation of
ClusterEventProducer.Use the
DefaultEncoderA
MergePolicyFactory for the default MergePolicy.This is a serializable bean (for the JSON that is stored in /repository.json) representing a
repository of Solr packages.
Standard implementation of tool runtime when running from command line.
An update processor that adds a constant default value to any document being added that does not
already have a value in the specified field.
A counter implementation that is aware of both primary and delegate metrics belonging to
different registries and able to update metrics in multiple registries
A meter implementation that is aware of both primary and delegate metrics belonging to different
registries and able to update metrics in multiple registries
A meter implementation that is aware of both primary and delegate metrics belonging to different
registries and able to update metrics in multiple registries
A timer implementation that is aware of both primary and delegate metrics belonging to different
registries and able to update metrics in multiple registries
Delegates to another
BackupRepository.This implementation allows Solr to dynamically change the underlying implementation of
ClusterEventProducer in response to the changed plugin configuration.A simple delegating collector where one can set the delegate after creation
A
SolrEventListener wrapper that loads class from a package and reload if it's modifiedHelper class to support dynamic reloading of plugin implementations.
A
SolrQueryRequest implementation that defers to a delegate in all cases.An overseer command used to delete files associated with incremental backups.
V2 API for deleting collections.
V2 API definitions for collection-backup deletion.
Delete collection request.
V2 API impl for Deleting Collection Snapshots.
V2 API implementation for ConfigsetsApi.Delete
V2 API for deleting all replicas of all collections in one node.
V2 APIs for deleting one or more existing replicas from one or more shards.
V2 API implementation for removing a property from a collection replica
Delete replicas request.
V2 API implementation for deleting a particular shard from its collection.
Delete shards request.
This class implements the functionality of deleting a collection level snapshot.
Provides a field type to support Lucene's
KnnByteVectorField
and KnnFloatVectorField.Utility to log a deprecation.
Factory for
DFISimilarityFactory for
DFRSimilarityEncapsulates shared fields for all types of dictionaryFactory classes
Provides access to a Directory implementation.
Hint about what the directory will be used for.
Deprecated.
Spellchecker implementation that uses
DirectSpellCheckerDirectUpdateHandler2 implements an UpdateHandler where documents are added directly
to the main Lucene index as opposed to adding to a separate smaller index.Query parser for dismax queries
Create a dismax query from the input value.
Used with a spatial field type for all distance measurements.
Class holding the implementation required for tracking asynchronous Collection API (or other)
tasks when the Collection API is distributed.
Gives access to distributed cluster state update methods and allows code to inquire whether
distributed state update is enabled.
Naming of enum instances are the mutator object name (e.g.
Class handling the distributed updates of collection's Zookeeper files
state.json based
on multiple updates applied to a single collection (as is sometimes done by *Cmd classes
implementing the Collection API commands).Class for execution Collection API and Config Set API commands in a distributed way, without
going through Overseer and
OverseerCollectionMessageHandler or OverseerConfigSetMessageHandler.A lock that can be used across cluster nodes.
A distributed map.
A lock as acquired for running a single API command (Collection or Config Set or anything else in
the future).
Values this processor supports for the
DISTRIB_UPDATE_PARAM.Factory for
DistributedUpdateProcessor.A marker interface for denoting that a factory is responsible for handling distributed
communication of updates across a SolrCloud cluster.
This Factory generates an UpdateProcessor that helps to enforce Version constraints on documents
based on per-document version numbers using a configured
versionField, a
comma-delimited list of fields to check for version numbers.Update Processor Factory for managing automatic "expiration" of documents.
Augments the document with a
[docid] integer containing it's current (internal) id
in the lucene index.Information for the current document in the
DocIterator.Simple Iterator of document Ids which may include score information.
DocList represents the result of a query: an ordered list of document ids with
optional score.An immutable ordered set of Lucene Document Ids.
Adapted from DocIdSetBuilder to build DocSets
DocSlice implements DocList as an array of docids and optional scores.This streams SolrDocuments from a DocList and applies transformer
This class enables fast access to multiple term ords for a specified field across all docIDs.
A DocTransformer can add, remove or alter a Document before it is written out to the Response.
Trivial Impl that ensure that the specified field is requested as an "extra" field, but then
does nothing during the transformation phase.
Transform a document before it gets sent out
An analysis handler that provides a breakdown of the analysis process of provided documents.
Builds a Lucene
Document from a SolrInputDocument.Factory for
DocumentDictionaryFactory for
DocumentValueSourceDictionaryAccumulates stats separated by slot number for the fields with
DocValuesComputes term facets for docvalues field (single or multivalued).
A helper class for random-order value access over docValues (such as in the case of
useDocValuesAsStored).
Supplies (and coordinates arbitrary-order value retrieval over) docValues iterators for a
particular field, encapsulating the logic of iterator creation, reuse/caching, and advancing.
Computes term stats for docvalues field (single or multivalued).
Read using DOM
PointField implementation for Double values.Field type for double ranges with support for 1-4 dimensions.
Simple holder class for parsed double range values.
Marker interface for double-valued field types.
Abstract
ValueSource implementation which wraps two ValueSources and applies an
extendible double function to their values.An efficient map for storing keys as integer in range from 0..n with n can be estimated up-front.
A wrapper
Collector that throws EarlyTerminatingCollectorException) once a
specified maximum number of documents are collected.Thrown by
EarlyTerminatingCollector when the maximum to abort the scoring / collection
process early, when the specified maximum number of documents were collected.Used to mark whether a document has been elevated or not
SolrClient that connects directly to a CoreContainer.
Responsible for transforming the grouped result into the final format for displaying purposes.
Abstracts the source for
SolrDocument instances.Deprecated.
use
EnumFieldType instead.Field type for support of string values with custom sort order.
Environment variable based SSL configuration provider
Directory provider for implementations that do not persist over reboots.
Compares two values for equality.
This class implements exact caching of statistics.
This class implements exact caching of statistics.
Interface for providing pluggable exchange rate providers to @CurrencyField
The ExpandComponent is designed to work with the CollapsingPostFilter.
Prepares and writes the documents requested by /export requests
Stream implementation that helps supporting 'expr' streaming in export writer.
A ValueSource parser configured with a pre-compiled expression that can then be evaluated at
request time.
A bindings class that uses schema fields to resolve variables.
Query parser that generates DisjunctionMaxQueries based on user configuration.
Simple container for configuration information used when parsing queries
A subclass of SolrQueryParser that supports aliasing fields for constructing
DisjunctionMaxQueries.
A simple container for storing alias info
An advanced multi-field query parser based on the DisMax parser.
The ExtendedQuery interface provides extra metadata to a query.
Deprecated.
ExternalFileField is an old capability of Solr that pre-dated in-place partial
updates of numeric DocValue fields.
An event listener to reload ExternalFileFields for new searchers.
Rule Based Authz plugin implementation which reads user roles from the request.
Computes facets -- aggregations with counts of terms or ranges over the whole search results.
This API is experimental and subject to change
This API is experimental and subject to change
Encapsulates facet ranges and facet queries such that their parameters are parsed and cached
for efficient re-use.
This class is used exclusively for merging results from each shard in a distributed facet
request.
This API is experimental and subject to change
This API is experimental and subject to change
This API is experimental and subject to change
JSON Facet API request for a 2D spatial summary of a rectangular region.
Base abstraction for a class that computes facets.
A request to do facets/stats that might itself be composed of sub-FacetRequests.
Are we doing a query time graph across other documents
Are we doing a query time join across other documents
Simple structure for encapsulating a sort variable and a direction
Provides the ability to specify multiple field types and field names in the same request.
Expert: Maintains caches of term values.
EXPERT: A unique Identifier/Description for each item in the FieldCache.
Placeholder indicating creation of this cache is currently in-progress.
interface to all parsers.
Base class for points parsers.
Expert: The default cache implementation, storing all values in memory.
FieldFacetStats is a utility to accumulate statistics on a set of values in one field, for facet
values present in another field.
Replaces any CharSequence values found in fields matching the specified conditions with the
lengths of those CharSequences (as an Integer).
Reusable base class for UpdateProcessors that will consider AddUpdateCommands and mutate the
values associated with configured fields.
Interface for identifying which fields should be mutated
Base class for implementing Factories for FieldMutatingUpdateProcessors and
FieldValueMutatingUpdateProcessors.
In the FieldNameMutatingUpdateProcessorFactory configured below, fields names will be mutated if
the name contains space.
Placeholder value source.
A class to hold "phrase slop" and "boost" parameters for pf, pf2, pf3 parameters
Create a field query from the input value, applying text analysis and constructing a phrase query
if appropriate.
Base class for all field types used by an index schema.
An enumeration representing various options that may exist for selecting a single value from a
multivalued field.
Utility class for converting a JSON definition of a FieldType into the XML format expected by the
FieldTypePluginLoader.
The following ord visitors and wrappers are a work in progress and experimental
Abstract subclass of FieldMutatingUpdateProcessor for implementing UpdateProcessors that will
mutate all individual values of a selected field independently
Base class for processors that want to mutate selected fields to only keep a subset of the
original values.
A spell checker implementation that loads words from a text file (one word per line).
Factory for
FileDictionaryConfiguration for currency.
Obtains float field values from an external file.
The interface to be implemented by any package store provider * @lucene.experimental
Common utilities used by filestore-related code.
FileSystem ConfigSetService impl.
Utility class to guess the mime type of file based on its magic number.
A collector that filters incoming doc ids that are not in the filter.
Abstract decorator class for a DocIdSet implementation that provides on-demand
filtering/validation mechanism on a given DocIdSet.
A
SolrMetricReporter that supports (prefix) filters.A filtered query wrapped around another query similar to
BooleanClause.Occur.FILTER -- it scores as 0.Keeps only the first value of fields matching the specified conditions.
Represents an operation that accepts a single
float-valued argument and returns no
result.PointField implementation for Float values.Field type for float ranges with support for 1-4 dimensions.
Simple holder class for parsed float range values.
Marker interface for float-valued field types.
V2 API implementation for triggering a leader election on a particular collection and shard.
LookupFactory implementation for
FreeTextSuggesterFactory for
FSTCompletionLookupDoes "function query" parsing of function-call like strings, producing a
ValueSource.Create a function query from the input value.
Create a range query over a function.
Factory for
FuzzySuggesterPlugin for parsing and creating Lucene
FuzzyQuerys with all customizations available.Parses "geodist" creating
HaversineConstFunction or HaversineFunction or calling
SpatialStrategy.makeDistanceValueSource(org.locationtech.spatial4j.shape.Point,double).Deprecated.
Deprecated.
Extend the standard JSONResponseWriter to support GeoJSON.
This DocumentTransformer will write a
Shape to the SolrDocument using the requested
format.V2 API for fetching the authentication section from Solr's security.json configuration.
V2 API for fetching the authorization section of Solr's security.json configuration.
Deprecated.
Please use
ClusterFileStoreApis.V2 APIs for retrieving some or all configuration relevant to a particular collection (or core).
Implementation of V2 API interface
GetNodeCommandStatusApi for checking the status of a
core-level asynchronous command.V2 API implementation to fetch the public key of the receiving node.
GetSchemaFieldAPI contains the V2 APIs for all field related endpoint which are
/fields
/fields/{fieldName}
/copyfields
/dynamicfields
/dynamicfields/{fieldName}
/fieldtypes
/fieldtypes/{fieldTypeName}
V2 API implementation for
SegmentsApiSolr Request Handler for graph traversal with streaming functions that responds with GraphML
markup.
Query parser plugin for solr to wrap the graph query parser.
GraphQuery - search for nodes and traverse edges in an index.
Solr query parser that will handle parsing graph query requests.
The GraphTermsQuery builds a disjunction query from a list of terms.
Implementation of
EndResultTransformer that keeps each grouped result separate in the
final response.Basic Solr Grouping infrastructure.
Encapsulates the grouping options like fields group sort and more specified by clients.
syntax fq={!hash workers=11 worker=4 keys=field1,field2}
Matches documents where the specified field hashes to a value within the given range.
Marker interface for field types that have an implicit (non-user-configurable) index-time schema.
Haversine function with one point constant
Calculate the Haversine formula (distance) between any two points on a sphere Takes in four value
sources: (latA, lonA); (latB, lonB).
Health Check Handler for reporting the health of a specific node.
Factory for
HighFrequencyDictionaryHighlights query words in the search results.
A probabilistic set of hashed
long elements.The types of algorithm/data structure that
HLL can utilize.Use the
SimpleHTMLEncoderUse the
SimpleHTMLFormatterStrips all HTML Markup in any CharSequence values found in fields matching the specified
conditions.
Plugin interface for configuring internal HttpClients.
Strategy for creating metric names for HttpClient Copied from metrics-httpclient library
An
AuthorizationContext implementation that delegates many methods to an underlying
HttpServletRequestA Carrier for extract Span context out of request headers
Solr's default
ShardHandler implementation; uses Jetty's async HTTP Client APIs for
sending requests.Creates
HttpShardHandler instancesThis class represents a call made to Solr
Factory for
IBSimilarityHelper class for generating unique ID-s.
Gives system administrators a way to ignore explicit commit or optimize requests from clients.
Ignores & removes fields matching the specified conditions from any document being added to
the index.
Gives system administrators a way to ignore very large update from clients.
This Cluster Singleton can be configured to periodically find and remove
Slice.State.INACTIVE Shards that are left behind after a Shard is
splitResponsible for orchestrating the actual incremental backup process.
A spell checker implementation that loads words from Solr as well as arbitrary Lucene indices.
A wrapper for an IndexDeletionPolicy instance.
Provides functionality of downloading changed index files as well as config files and a timer for
scheduling fetches from the leader.
Wraps an
IndexOutput to expose it as an OutputStream.Factory used to build a new IndexReader instance.
IndexSchema contains information about the valid fields in an index and the types of
those fields.Base class for factories for IndexSchema implementations
Estimates the raw size of all uncompressed indexed data by scanning term, docValues and stored
fields data.
An Object which represents a
<initParams> tagAllows access to a
ContainerRequestContext via a ServiceLocatorFetch the (existing) SolrCore from the request context
V2 API implementation of the "Install Core Data" Core-Admin API
v1 shim implementation of the "Install Core Data" API, a core-admin API used to implement the
"Install Shard Data" Collection-Admin functionality
V2 API implementation allowing users to import offline-constructed index into a shard.
Overseer processing for the "install shard data" API.
A value-type representing the message received by
InstallShardDataCmdA HttpListenerFactory tracking metrics and distributed tracing.
Sub-class of HttpRequestExecutor which tracks metrics interesting to solr Inspired and partially
copied from dropwizard httpclient library
Sub-class of PoolingHttpClientConnectionManager which tracks metrics interesting to Solr.
Computes interval facets for docvalues field (single or multivalued).
Helper class to match and count of documents in specified intervals
PointField implementation for Integer values.Field type for integer ranges with support for 1-4 dimensions.
Simple holder class for parsed integer range values.
Marker interface for int-valued field types.
A Function that may throw an IOException
A serialization schema for HLLs.
Reads 'words' of a fixed width, in sequence, from a byte array.
A JSON ResponseWriter that uses jackson.
A
MapWriter implementation that relies on Jackson's JsonProperty annotation.Deprecated.
Migrate to one of the newer suggesters which are much more RAM efficient.
Factory for
JaspellLookup Note: This Suggester is not very RAM efficient.Deprecated.
Migrate to one of the newer suggesters which are much more RAM efficient.
An inner class of Ternary Search Trie that represents a node in the trie.
Update handler which uses the JavaBin format
Stores Jersey 'ApplicationHandler' instances by an ID or hash derived from their
ConfigSet.JAX-RS "application" configurations for Solr's
CoreContainer and
SolrCore instancesA marker parent type for all Jersey "resource" classes.
A ResponseWriter which copies that output of JAX-RS computation over to
HttpServletResponse object used by the Jetty server.This is a modified copy of Dropwizard's
JmxReporter and classes
that it internally uses, with a few important differences:
this class knows that it can directly use MetricsMap as a dynamic MBean.Builder for the
JmxMetricsReporter class.Factory to create MBean names for a given metric.
Utility methods to find a MBeanServer.
A neural query parser to run K-nearest neighbors search on Dense Vector fields.
Keeps only the last value of fields matching the specified conditions.
Prevents any older version segment (i.e.
A
MergePolicyFactory for LatestVersionMergePolicy objects.A spatial implementation based on Lucene's
LatLonPoint and LatLonDocValuesField.Leader Election process.
We use this watcher to wait for any eligible replica in a shard to become active so that it can
become a leader.
Deprecated.
Please use
DoublePoint insteadDeprecated.
Please switch to
PointValues insteadDeprecated.
Please switch to
PointValues insteadDeprecated.
Please use
FloatPoint insteadDeprecated.
Please use
IntPoint insteadDeprecated.
Please use
LongPoint insteadDeprecated.
Instead index with
IntPoint, LongPoint, FloatPoint, DoublePoint, and create range queries with IntPoint.newRangeQuery(), LongPoint.newRangeQuery(), FloatPoint.newRangeQuery(), DoublePoint.newRangeQuery() respectively.Deprecated.
Index with points and use
PointRangeQueryBuilder insteadDeprecated.
Please switch to
PointValues insteadExpert: Use this attribute to get the details of the currently generated token.
Implementation of
LegacyNumericTokenStream.LegacyNumericTermAttribute.Deprecated.
Please switch to
PointValues insteadDeprecated.
Please use
PointValues instead.Supports linking a configset to a collection
V2 API for listing any currently running "tasks".
V2 API implementation for listing and inspecting collection aliases
V2 API implementations for collection-backup "listing".
V2 API for listing collections.
V2 API implementation for Listing Collection Snapshots.
V2 API implementation for listing all available configsets.
Factory for
LMDirichletSimilarityFactory for
LMJelinekMercerSimilarityA simple servlet to load the Solr Admin UI
Tracks current system load average and triggers if the specified threshold is breached.
A concrete implementation of BackupRepository interface supporting backup/restore of
Solr indexes to a local file-system.
Deprecated.
Default implementation that simply ignores global term statistics, and always uses local term
statistics.
Convenience class that wraps a local
SolrIndexSearcher to provide local statistics.This is a utility class that offers fine grained locking for various Collection Operations This
class is designed for single threaded operation.
A
MergePolicyFactory for LogByteSizeMergePolicy objects.A
MergePolicyFactory for LogDocMergePolicy objects.Wrapper class for Logger implementations
A request handler to show which loggers are registered and allows you to set them
An
InfoStream implementation which passes messages on to Solr's logging.A logging processor.
A Class to monitor Logging events and hold N events in memory
Defines the configuration of a
LogWatcherA
long-based iterator.PointField implementation for Long values.A native long priority queue.
Field type for long ranges with support for 1-4 dimensions.
Simple holder class for parsed long range values.
Marker interface for long-valued field types.
Suggester factory for creating
Lookup instances.Deprecated.
Use
LetterTokenizer and LowerCaseFilterDeprecated.
Use
LetterTokenizerFactory and LowerCaseFilterFactoryUnlike
ExactStatsCache this implementation preserves term stats across queries in a set
of LRU caches (with the same life-cycle as SolrIndexSearcher), and based on surface features of a
query it determines the need to send additional requests to retrieve local term and collection
statistics from shards.Simple factory for returning the Lucene default Codec
Parse Solr's variant on the Lucene QueryParser syntax.
Exposes the internal lucene index.
Implementation of
EndResultTransformer that transforms the grouped result into the main
result list in the response.Solr-managed schema - non-user-editable, but can be mutable via internal and external REST API
requests.
Factory for ManagedIndexSchema
Supports Solr components that have external data that needs to be managed using the REST API.
Marker interface to indicate a ManagedResource implementation class also supports managing
child resources at path: /<resource>/{child}
Allows a Solr component to register as an observer of important ManagedResource events, such as
when the managed data is loaded.
Abstract base class that provides most of the functionality needed to store arbitrary data for
managed resources.
Local file-based storage implementation.
Memory-backed storage IO; not really intended for storage large amounts of data in production,
but useful for testing and other transient workloads.
Default storage implementation that uses JSON as the storage format for managed data.
Hides the underlying storage implementation for data being managed by a ManagedResource.
ZooKeeper based storage implementation that uses the SolrZkClient provided by the
CoreContainer.
Utility methods for comparing managed index schemas
TokenFilterFactory that uses the ManagedWordSetResource implementation for managing stop words
using the REST API.
Deprecated.
Use
ManagedSynonymGraphFilterFactory instead, but be sure to also use FlattenGraphFilterFactory at index time (not at search time) as well.ManagedResource implementation for synonyms, which are so specialized that it makes sense to
implement this class as an inner class as it has little application outside the
SynonymFilterFactory use cases.
TokenFilterFactory and ManagedResource implementation for doing CRUD on synonyms using the REST
API.
ManagedResource implementation for synonyms, which are so specialized that it makes sense to
implement this class as an inner class as it has little application outside the
SynonymFilterFactory use cases.
ManagedResource implementation for managing a set of words using the REST API; useful for
managing stop words and/or protected words for analysis components like the KeywordMarkerFilter.
A plugin that can be initialized with a Map<String,String>
Wraps another map, keeping track of each key that was seen via
MapListener.get(Object) or MapListener.remove(Object).Wraps a
Query to customize the TwoPhaseIterator.matchCost().Search component that enriches the response with named-match information for each document in the
top-N hits.
An update processor that keeps only the maximum value from any selected fields where multiple
values are found.
A
Collector for the maximum score value.Parses a query like Lucene query parser, but scoring with max score, not sum
Accepts the "tie" request parameter as with dismax.
Accepts the "tie" request parameter as with dismax.
Set's per thread context info for logging.
Takes a 'snapshot' of the current MDC context map which is restored on (auto) close.
Overrides the content-type of the response based on an optional user-provided 'wt' parameter
Enforces a memory-based limit on a given SolrQueryRequest, as specified by the
memAllowed
query parameter.Trips when post-GC live heap data exceeds a configured percentage of the maximum heap size.
Implementation of V2 API interface
MergeIndexesApi for merging one or more indexes to
another index.A merge indexes command encapsulated in an object.
A
MergePolicyFactory for SortingMergePolicy objects.A factory for creating a
MergePolicy.The MergeStrategy class defines custom merge logic for distributed searches.
A collection point for various
MessageBodyReader implementations.Caches the deserialized request body in the
ContainerRequestContext for use later in
the request lifecycle.A JSON
MessageBodyReader that caches request bodies for use later in the request
lifecycle.A collection of thin Jersey shims around Solr's existing
QueryResponseWriter interfaceMetric-related attribute of a node or replica.
Base class for
Metric implementations.Handler to collect and aggregate metric reports.
Request handler to return metrics
Dynamically constructed map of metrics, intentionally different from
MetricSet where each metric had to be known in advance and registered
separately in MetricRegistry.Helper class for constructing instances of
MetricRegistry.MetricSupplier based on plugin configuration.Default
Counter supplier.Default supplier of
Histogram instances, with configurable reservoir.Default
Meter supplier.Default supplier of
Timer instances, with configurable clock and reservoir.No-op implementation of
Counter supplier.No-op implementation of
Gauge.No-op implementation of
Histogram supplier.No-op implementation of
Meter supplier.Marker interface for all no-op metrics.
No-op implementation of
Timer supplier.Metrics specific utility functions.
V2 API for migrating docs from one collection to another.
V2 API for migrating replicas from a set of nodes to another set of nodes.
An update processor that keeps only the minimum value from any selected fields where multiple
values are found.
The query parser can be used in two modes 1) where text is analysed and generates min hashes as
part of normal lucene analysis 2) where text is pre-analysed and hashes are added as string to
the index An analyzer can still be defined to support text based query against the text field
QParserPlugin based on MinHashQParser.Factory for creating
MinimizeCoresPlacementFactory.MinimizeCoresPlacementPlugin, a Placement plugin implementing
placing replicas to minimize number of cores per Node, while not placing two replicas of
the same shard on the same node.AggValueSource to compute missing counts for given ValueSourceUsage: {!mlt qf=queryField1,queryField2}uniqueId
Directly provide MMapDirectory instead of relying on
FSDirectory.open(java.nio.file.Path).Deprecated.
Collection modification request.
Helper class to create modification request instances.
V2 API to modify configuration for Solr's
BasicAuthPluginV2 API for modifying collections.
V2 APIs for creating, updating, or deleting individual components in a collection configuration.
V2 API to modify configuration options for the
MultiAuthPlugin.V2 API for POST requests received when no authentication plugin is active.
V2 API for POST requests received when no authorization plugin is active.
V2 APIs for creating, modifying, or deleting paramsets.
V2 API to modify configuration options for the
RuleBasedAuthorizationPlugin.Parses the list of modules the user has requested in solr.xml, property solr.modules or
environment SOLR_MODULES.
V2 API for performing a more like this request to a solr collection.
TODO!
Solr MoreLikeThis --
Helper class for MoreLikeThis that can be called from other request handlers
V2 API for moving a collection replica to a different physical node.
Authentication plugin that supports multiple Authorization schemes, such as Bearer and Basic.
Authorization plugin designed to work with the MultiAuthPlugin to support different
AuthorizationPlugin per scheme.
Audit logger that chains other loggers.
Abstract
ValueSource implementation which wraps multiple ValueSources and applies an
extendible string function to their values.Populates a bitset of (top-level) ordinals based on field values in a multi-valued field.
A plugin that can be initialized with a NamedList
Create a nested query, with the ability of that query to redefine its type via local parameters.
An interface for RequestHandlers need to handle all paths under its registered path
Adds fields to nested documents to support some nested search requirements.
To be used for field
IndexSchema.NEST_PATH_FIELD_NAME for enhanced nested doc
information.Factory to instantiate
NIOFSDirectoryRepresentation of a SolrCloud node or server in the SolrCloud cluster.
Plugin configurations that are defined in solr.xml.
Implementation for
NodeFileStoreApisV2 API for checking the health of the receiving node.
V2 APIs for getting or setting log levels on an individual node.
Node metric identifier, corresponding to a node-level metric registry and the internal metric
name.
Registry options for node metrics.
Node metric identifier, corresponding to a node-level metric registry and the internal metric
name.
V2 API for listing system properties for each node.
Event generated when some nodes went down.
Event generated when some nodes went up.
V2 API for getting "system" information from the receiving node.
V2 API for triggering a thread dump on the receiving node.
A No-Op implementation of DistributingUpdateProcessorFactory that allways returns the next
processor instead of inserting a new URP in front of it.
No-op implementation of
ClusterEventProducer.Cache regenerator that just populates the new cache with the old items.
An
ExceptionMapper for the exception produced by JAX-RS when no match could be found for
an incoming request.Does nothing other than showing a 404 message
Factory to instantiate
NRTCachingDirectoryDeprecated.
Query parser for numeric range fields with support for different query relationship types.
Query relationship criteria for range queries.
Marker interface for numeric-valued field types.
This factory generates an UpdateRequestProcessor which fails update requests once a core has
exceeded a configurable maximum number of fields.
Context passed to Collection API commands when they execute in the Overseer.
Exchange Rates Provider for
CurrencyField and CurrencyFieldType capable of
fetching & parsing the freely available exchange rates from openexchangerates.orgThis is an extended replacement for
FileDescriptorRatioGauge -
that class uses reflection and doesn't work under Java 9.A class that determines the weight of a given node and the replicas that reside on it.
Obtains the ordinal of the field value from
LeafReader.getSortedDocValues(java.lang.String).Simple Augmenter that adds the originalScore
Cluster leader.
Enum of actions supported by the overseer only.
An
OverseerTaskProcessor that handles: 1) collection-related Overseer messages 2)
configset-related Overseer messagesA
OverseerMessageHandler that handles Collections API related overseer messages.A
OverseerMessageHandler that handles ConfigSets API related overseer messages.Interface for processing messages received by an
OverseerTaskProcessorResponsible for prioritization of Overseer nodes, for example with the ADDROLE collection
command.
V2 API for triggering a node to rejoin leader election for the 'overseer' role.
This command returns stats about the Overseer, the cluster state updater and collection API
activity occurring within the current Overseer node (this is important because distributed
operations occurring on other nodes are not included in these stats, for example
distributed cluster state updates or Per Replica States updates).
A generic processor run in the Overseer, used for handling items added to a distributed work
queue.
An interface to determine which
OverseerMessageHandler handles a given message.A
ZkDistributedQueue augmented with helper methods specific to the overseer task queues.This implements the public end points (/api/cluster/package) of package API.
A
SolrClassLoader that is designed to listen to a set of packages.Handles most of the management of packages that are already installed in Solr.
Abstract class for a repository, holding
SolrPackage items.A version of
HttpShardHandler optimized for massively-sharded collections.Creates
ParallelHttpShardHandler instancesAttempts to mutate selected fields that have only CharSequence-typed values into Boolean values.
Attempts to mutate selected fields that have only CharSequence-typed values into Date values.
Attempts to mutate selected fields that have only CharSequence-typed values into Double values.
This exception is thrown when parse errors are encountered.
Attempts to mutate selected fields that have only CharSequence-typed values into Float values.
Attempts to mutate selected fields that have only CharSequence-typed values into Integer values.
Attempts to mutate selected fields that have only CharSequence-typed values into Long values.
Abstract base class for numeric parsing update processor factories.
Implements a
CertPrincipalResolver that resolves a Principal from an X509
certificate based on configurable paths, filters, and optional extraction patterns.Abstract base class for implementing path-based certificate resolvers.
Denotes an object, usually a servlet that denies access to some paths based on the supplied
patterns.
Holds the deserialized object for each command and also holds request , response objects
Creates a
PayloadScoreQuery wrapping a SpanQuery created from the input value, applying
text analysis and constructing SpanTermQuery or SpanNearQuery based on number of terms.This class is useful for performing peer to peer synchronization of recently indexed update
commands during recovery process.
Helper class for doing comparison ourUpdates and other replicas's updates to find the updates
that we missed
Result of
PeerSync.MissedUpdatesFinderHelper class for doing comparison ourUpdates and other replicas's updates to find the updates
that we missed
Associates the resource method with a particular
PermissionNameProvider value.A requestHandler should implement this interface to provide the well known permission at request
time
Deprecated.
Deprecated.
A component that can be used in isolation, or in conjunction with
QueryComponent to
identify & score "phrases" found in the input string, based on shingles in indexed fields.Model the data known about a single (candidate) Phrase -- which may or may not be indexed
Simple container for all request options and data this component needs to store in the Request
Context
Ping Request Handler for reporting SolrCore health to a Load Balancer.
Models a single instance of a "pivot" specified by a
FacetParams.FACET_PIVOT param, which
may contain multiple nested fields.Models a single field somewhere in a hierarchy of fields as part of a pivot facet.
Emcapsulates a collection of
PivotFacetValues associated with a PivotFacetField
withs pecial tracking of a PivotFacetValue corrisponding to the null value
when FacetParams.FACET_MISSING is used.Sorts
PivotFacetValue instances by their countSorts
PivotFacetValue instances by their valueProcesses all Pivot facet logic for a single node -- both non-distrib, and per-shard
Models a single (value, count) pair that will exist in the collection of values for a
PivotFacetField parent.Enum for modeling the elements of a (nested) pivot entry as expressed in a NamedList
Placement context makes it easier to pass around and access main placement-related components.
Exception thrown by a
PlacementPlugin when it is unable to compute placement for whatever
reason (except an InterruptedException that PlacementPlugin.computePlacement(org.apache.solr.cluster.placement.PlacementRequest, org.apache.solr.cluster.placement.PlacementContext) is
also allowed to throw).Exception thrown when a placement modification is rejected by the placement plugin.
A fully specified plan or instructions for placement, deletion or move to be applied to the
cluster.
Allows plugins to create
PlacementPlans telling the Solr layer where to create replicas
following the processing of a PlacementRequest.Simple implementation of
PlacementPlanFactory.Implemented by external plugins to control replica placement and movement on the search cluster
(as well as other things such as cluster elasticity?) when cluster changes are required
(initiated elsewhere, most likely following a Collection API call).
This assign strategy delegates placement computation to "plugin" code.
Configuration beans should use this interface to define public (mutable) configuration
properties.
Factory implemented by client code and configured in container plugins (see
ContainerPluginsApi.editAPI) allowing the creation of instances of
PlacementPlugin to be used for replica placement computation.Useful type for plugins that don't use any configuration.
Utility class to work with
PlacementPluginFactory plugins.A cluster related placement request that Solr asks a
PlacementPlugin plugin to resolve
and compute a PlacementPlan placing one or more Replica's of one or more Shard's of an existing SolrCollection.This manages the lifecycle of a set of plugin of the same type .
Allows JAX-RS 'filters' to find the requestHandler (if any) associated particular JAX-RS
resource classes
An indirect reference to a plugin.
An Object which represents a Plugin of any type
A plugin that can be initialized with a PluginInfo
Provides field types to support for Lucene's
IntPoint, LongPoint, FloatPoint and DoublePoint.Merge multiple numeric point fields (segments) together.
A point type that indexes a point in an n-dimensional space as separate fields and supports range
queries.
Given a list of possible Spelling Corrections for multiple mis-spelled words in a query, This
iterator returns Possible Correction combinations ordered by reasonable probability that such a
combination will return actual hits if re-queried.
The PostFilter interface provides a mechanism to further filter documents after they have already
gone through the main query and other filters.
A command line tool for indexing Solr logs in the out-of-the-box log format.
Applies standard post-processing decorations to a
SolrJerseyResponse that are needed on
all responses.Utility class to hold the result form a page fetch
Pre-analyzed field type provides a way to index a serialized token stream, optionally with an
independent stored value of a field.
This is a simple holder of a stored part and the collected states (tokens with attributes).
Parse the input and return the stored part and the tokens with attributes.
An update processor that parses configured fields of any document being added using
PreAnalyzedField with the configured format parser.Create a prefix query from the input value.
Internal V2 API used to prepare a core for recovery.
Abstract class defining shared behavior for primitive types Intended to be used as base class for
non-analyzed fields like int, float, string, date etc, and set proper defaults for them
Utilities for primitive Java data types.
Wrapper for PrintWriter that delegates to constructor arg
Category of prefix Solr Core dropwizard handler metric names
Category of prefix Solr JVM dropwizard handler metric names
Category of prefix Solr Node dropwizard handler metric names
Response writer for Prometheus metrics.
Deprecated.
Note: This API is experimental and may change in non backward-compatible ways in the
future
The QueryAndResponseCombiner class is an abstract base class for combining query results and
shard documents.
Responsible for handling query cancellation requests
Handles requests for query cancellation for cancellable queries
A query request command to avoid having to change the method signatures if we want to pass
additional information to the searcher.
Encapsulates
TopDocs and the number of matches.TODO!
Fake scorer for a single document
The QueryConverter is an abstract base class defining a method for converting input "raw" queries
into a set of tokens for spell checking.
A component to elevate some documents to the top of the result set.
Query triggering elevation.
Elevation of some documents in search results, with potential exclusion of others.
Provides the elevations defined for queries.
Matches a potentially large collection of subsets with a trie implementation.
Represents the limitations on the query.
The default operator for parsing queries.
Token literal values and constants.
Token Manager.
Collection of static utilities useful for query parsing.
Implementation of RequestRateLimiter specific to query request types.
Implementations of
QueryResponseWriter are used to format responses to query
requests.Static utility methods relating to
QueryResponseWritersThe result of a search.
A hash key encapsulating a query, a list of filters, and a sort
Factory to instantiate RAM-resident directory implementation.
Factory for creating
RandomPlacementFactory.RandomPlacementPlugin, a placement plugin implementing random
placement for new collection creation while preventing two replicas of same shard from being
placed on same node..Utility Field used for random sorting.
Processor for Range Facets
Encapsulates a single facet.range request along with all its parameters.
Represents a single facet range (or gap) for which the count is to be calculated
RankFields can be used to store scoring factors to improve document ranking.RankQParserPlugin can be used to introduce document-depending scoring factors to ranking.Note: This API is experimental and may change in non backward-compatible ways in the
future
This class is responsible for managing rate limiting per request type.
Create a term query from the input value without any text analysis or transformation whatsoever.
Writes a ContentStream directly to the output.
Factory for RawTFSimilarity.
V2 API for fetching the latest (possibly uncommitted) version of one or more documents.
Lookup strategy for some methods on this class.
V2 API for balancing shard leaders in a collection across nodes.
This class implements a query and response combiner that uses the Reciprocal Rank Fusion (RRF)
algorithm to combine multiple ranked lists into a single ranked list.
Start recovery of a core if its term is less than leader's term
This class may change in future and customisations are not supported between versions in terms of
API or back compat behaviour.
A Simple redirection servlet to help us deprecate old UI elements
Keep track of a reference count on a resource and close it when the count hits zero.
Refresh the ClusterState for a given collection.
An implementation of
Predicate which returns true if the BytesRef matches the supplied
regular expression.Accepts any file whose name matches the pattern
Fragmenter that tries to produce snippets that "look"
like a regular expression.A processor which will match content of "inputField" against regular expressions found in
"boostFilename", and if it matches will return the corresponding boost value from the file and
output this to "boostField" as a double value.
Factory which creates RegexBoostProcessors
An updated processor that applies a configured regex to any CharSequence values found in the
selected fields, and replaces any matches with the configured replacement string.
Reindex a collection, usually in order to change the index schema.
V2 API for triggering a core to rejoin leader election for the shard it constitutes.
An aggregation function designed to be nested under other (possibly deeply nested) facets for the
purposes of computing the "relatedness" of facet buckets relative to "foreground" and
"background" sets -- primarily for the purpose of building "Semantic Knowledge Graphs"
V2 API implementation for reloading collections.
V2 API implementation for reloading an individual core.
Removes any values found which are CharSequence with a length of 0.
V2 API implementation to "rename" an existing collection
V2 API for renaming an existing Solr core.
V2 API for renaming an existing Solr core.
Return a field with a name that is different that what is indexed
V2 API for recreating replicas in one node (the source) on another node(s) (the target).
An instantiation (or one of the copies) of a given
Shard of a given SolrCollection.The order of this enum is important from the most to least "important" replica type.
Replica metric identifier, corresponding to one of the internal replica-level metric names (as
reported in
solr.core.[collection].[replica] registry)Replica metric identifier, corresponding to one of the internal replica-level metric names (as
reported in
solr.core.[collection].[replica] registry)Strongly-typed replica-level metrics.
Placement decision for a single
Replica.A common parent for "replication" (i.e.
A Handler which provides a REST API for replication and serves replication requests from
Followers.
Simple cache for reusable service clients used by some implementations of
SolrMetricReporter.Provide an instance of service client.
Handles most of the management of repositories and packages present in external repositories.
Internal V2 API used to apply updates to a core.
Internal V2 API used to start update-buffering on the specified core.
Keys used to store and retrieve values from the Jersey request context.
Internal V2 API triggering recovery on a core.
Base class for all request handlers.
Metrics for this handler.
Common helper functions for RequestHandlers
A request and response filter used to initialize and report per-request metrics.
Adjusts post-request metrics (timing, etc.)for individual Jersey requests.
Sets up the metrics-context for individual requests
The class encapsulates the request time parameters .
Handles rate limiting for a specific request type.
Internal V2 API used to request a core sync with its shard leader.
A
Weight used by reranking queries.This class is experimental and will be changing in the future.
Adds to the log file the document IDs that are sent in the query response.
Response helper methods.
Supports runtime mapping of REST API endpoints to ManagedResource implementations; endpoints can
be registered at either the /schema or /config base paths, depending on which base path is more
appropriate for the type of managed resource.
Request handling needs a lightweight object to delegate a request to.
Per-core registry of ManagedResources found during core initialization.
V2 API for restoring data into a collection
V2 API implementation for restoring a previously taken backup to a core
A class to hold the QueryResult and the Query
A class representing the return fields
This class produces a special form of reversed tokens, suitable for better handling of leading
wildcards.
Factory for
ReversedWildcardFilter-s.Obtains the ordinal of the field value from
LeafReader.getSortedDocValues(java.lang.String) and reverses the order.Distributes update requests to a series of collections partitioned by a "routing" field.
A Solr Spatial FieldType based on
CompositeSpatialStrategy.A simple timer.
A recursive timer.
Deprecated.
Original implementation of Rule Based Authz plugin which configures user/role mapping in the
security.json configuration
Base class for rule based authorization plugins
Supports an interactive session with the user to launch (or relaunch the -e cloud example)
Executes the update commands using the underlying UpdateHandler.
Some utility methods for parsing XML in a safe way.
An interface that can be extended to provide a callback mechanism for informing an
IndexSchema instance of changes to it, dynamically performed at runtime.V2 APIs for creating, updating, or deleting individual components in a collection's schema.
Per-field CodecFactory implementation, extends Lucene's and returns postings format
implementations according to the schema configuration.
All V2 APIs that have a prefix of /api/schema-designer/
Encapsulates all information about a Field in a Solr Schema
A utility class to manipulate schema using the bulk mode.
SimilarityFactory that returns a global PerFieldSimilarityWrapper that
delegates to the field type, if it's configured.Simple Augmenter that adds the score
Create a query-time join query with scoring.
TODO!
Creates all the collectors needed for the first phase and how to handle the results.
Encapsulates the result of a
SearchGroupsFieldCommand commandConcrete implementation for merging
SearchGroup instances from shard responses.Concrete implementation of
ShardRequestFactory that creates ShardRequest
instances for getting the search groups from all shards.Implementation for transforming
SearchGroup into a NamedList structure and visa
versa.Refer SOLR-281
Object to hold security.json as nested
Map<String,Object> and optionally its
version.Security Configuration Handler which works on standalone local files
Security Configuration Handler which works with Zookeeper
This handler exposes information about last commit generation segments
Provides a convenient extension of the
ServletInputStream class that can be subclassed by
developers wishing to adapt the behavior of a Stream.Provides a convenient extension of the
ServletOutputStream class that can be subclassed
by developers wishing to adapt the behavior of a Stream.Various Util methods for interaction on servlet level, i.e.
Shard in a
SolrCollection, i.e.Represents the ID of a particular backup point for a particular shard.
Represents the shard-backup metadata file.
Executes, tracks, and awaits all shard-requests made in the course of a distributed request.
Shard-level metrics.
Responsible for creating shard requests to the shards in the cluster to perform distributed
grouping.
Responsible for processing shard responses.
A
ShardResultTransformer is responsible for transforming a grouped shard result into
group related structures (such as TopGroups and SearchGroup) and visa versa.This handler uses the RawResponseWriter to give client access to files inside ${solr.home}/conf
CachingDirectoryFactory will call this method rather than Directory.close() on
shutdown if a Directory implements this interface.A factory interface for configuring a
Similarity in the Solr schema.xml.Implementation of
EndResultTransformer that transforms the grouped result into a single
flat list.A class that generates simple Facet information for a request.
A simple key=>val pair whose natural order is such that higher vals come before lower
vals.
A
MergePolicyFactory for simple MergePolicy objects.Implementation of
PlacementContext that uses SimpleClusterAbstractionsImpl to
create components necessary for the placement plugins to use.Factory for creating
SimplePlacementFactory.SimplePlacementPlugin, a placement plugin implementing the logic
from the old LegacyAssignStrategy.Deprecated.
This class is being replaced with bin/solr tool.
Utility class to hold the result form a page fetch
Simple plain text format parser for
PreAnalyzedField.Create a query from the input value that will be parsed by Lucene's SimpleQueryParser.
A base class for writing a very simple UpdateProcessor without worrying too much about the API.
V2 API for checking the status of a specific core.
A size limited distributed map maintained in zk.
This Factory generates an UpdateProcessor that will (by default) skip inserting new documents if
there already exists a document with the same uniqueKey value in the index.
Accumulates statistics separated by a slot number.
Incapsulates information about the current slot, for Accumulators that may want additional info
during collection.
This class forces a composite reader (eg a
MultiReader or DirectoryReader) to
emulate a LeafReader.Provides functionality equivalent to the snapshooter script This is no longer used in standard
replication.
v2 API implementation for replication-handler based backup creation.
Supports snapshot-create command in the bin/solr script.
Supports snapshot-delete command in the bin/solr script.
Supports snapshot-describe command in the bin/solr script.
Supports snapshot-export command in the bin/solr script.
Supports snapshot-list command in the bin/solr script.
An OpenTracing Carrier for injecting Span context through an Apache HttpRequest
Primary API for dealing with Solr's internal caches.
Enumeration of possible States for cache instances.
Common base class of reusable functionality for SolrCaches
Decides how many things to autowarm based on the size of another cache
Command-line utility for working with Solr.
Used for distributing commands from a shard leader to its replicas.
Represents a Collection in SolrCloud (unrelated to
Collection that uses the
nicer name).Refines
ComparisonBoolFunction to compare based on a 'long' or 'double' depending on if
the any of the FunctionValues are LongDocValues.Provides a static reference to a Config object modeling the main configuration data for a Solr
instance -- typically found in "solrconfig.xml".
SolrCore got its name because it represents the "core" of Solr -- one index and everything needed
to make it work.
Provides the core instance if the core instance is still alive.
Dropwizard metrics of name CACHE.*
A
SolrMetricReporter that has access to its CoreContainer.Dropwizard metrics of name ADMIN/QUERY/UPDATE/REPLICATION.*
Dropwizard metrics of name HIGHLIGHTER.*
Dropwizard metrics of name INDEX.*
Base class is a wrapper to export a solr.core
MetricHelper class for managing registration of
SolrMetricProducer's and SolrMetricReporter's specific to a SolrCore instance.Assembles a QueryBuilder which uses Query objects from Solr's
search module in
addition to Query objects supported by the Lucene CoreParser.A
FilteringSolrMetricReporter that has access to its SolrCore.AKA CoreManager: Holds/manages
SolrCores within CoreContainer.Dropwizard metrics of name SEARCHER.*
The state in this class can be easily shared between SolrCores across SolrCore reloads.
Dropwizard metrics of name TLOG.*
A default collection of mappings, used to convert strings into stream expressions.
This class represents a metrics context that is delegate aware in that it is aware of multiple
metric registries, a primary and a delegate.
Standard Solr deletion policy that allows reserving index commit points for certain amounts of
time to support features such as index replication or snapshotting directly out of a live index
directory.
This filter looks at the incoming URL maps them to handlers defined in solrconfig.xml
Enum to define action that needs to be processed.
internal API
A helper class of
SolrIndexSearcher for stored Document related
matters including DocValue substitutions.It is possible to define an environment code when starting Solr, through
-Dsolr.environment=prod|stage|test|dev or by setting the cluster property "environment".
A SolrInfoBean that provides introspection of the Solr FieldCache
Metrics reporter that wraps
GraphiteReporter.This config object encapsulates IndexWriter config params, defined in the <indexConfig>
section of solrconfig.xml
SolrIndexSearcher adds schema awareness and caching functionality over
IndexSearcher.INTERNAL: The response object from
SolrIndexSearcher.getProcessedFilter(DocSet, List).An IndexWriter that is configured via Solr config mechanisms.
Interface for getting various ui friendly strings for use by objects which are 'pluggable' to
make server administration easier.
Category of Solr component.
Top-level group of beans or metrics for a subsystem.
A request handler that provides info about all registered SolrInfoMBeans.
this class provides a mapping between Solr's
JsonProperty annotation to a corresponding
annotation in jackson see SOLR-13841 for more details
Customizes the ObjectMapper settings used for serialization/deserialization in Jersey
Base class is a wrapper to export a solr.jetty
MetricAn OpenTracing Carrier for injecting Span context through a Jetty Request
A
SolrMetricReporter that finds (or creates) a MBeanServer from the given configuration
and registers metrics to it with JMX.Base class is a wrapper to export a solr.jvm
MetricAudit logger that writes to the Solr log.
Deprecated.
Please use
PostLogsTool that is exposed as 'bin/solr postlogs'.Base class is a wrapper to categorize and export
Metric to DataPointSnapshot and register to a SolrPrometheusFormatter.Wraps meta-data for a metric.
This class maintains a repository of named
MetricRegistry instances, and provides several
helper methods for managing various aspects of metrics reporting:
registry creation, clearing and removal,
creation of most common metric implementations,
management of SolrMetricReporter-s specific to a named registry.An implementation of
MetricFilter that selects metrics that match all filters in a list
of filters.This is a wrapper for
Gauge metrics, which are usually implemented as lambdas that
often keep a reference to their parent instance.An implementation of
MetricFilter that selects metrics that match any filter in a list
of filters.An implementation of
MetricFilter that selects metrics with names that start with one
of prefixes.An implementation of
MetricFilter that selects metrics with names that match regular
expression patterns.Potential conflict resolution strategies when attempting to register a new metric that already
exists
Used by objects that expose metrics through
SolrMetricManager.Interface for 'pluggable' metric reporters.
This class represents a metrics context that ties together components with the same life-cycle
and provides convenient access to the metric registry.
A
CollectorManager implements which wrap a set of CollectorManager as MultiCollector acts for Collector.Creates and mediates access to the CryptoKeys.RSAKeyPair used by this Solr node.
Base class is a wrapper to export a solr.node
MetricDescribes a package (along with all released versions) as it appears in a repository.
Describes one instance of a package as it exists in Solr when installed.
The class that holds a mapping of various packages and classloaders
Utility methods about paths in Solr.
Builds a set of allowed
Path.Utilities that may be of use to RequestHandlers.
A subclass of SolrQueryParser that supports aliasing fields for constructing
DisjunctionMaxQueries.
A simple container for storing alias info
Class to interact with Solr OS processes
Represents a running Solr process
This class maintains a
MetricSnapshots exported
from solr.core MetricRegistryBase class for all
SolrPrometheusFormatter holding MetricSnapshots.This class maintains a
MetricSnapshots exported
from solr.jetty MetricRegistryThis class maintains a
MetricSnapshots exported
from solr.jvm MetricRegistryThis class maintains a
MetricSnapshots exported
from solr.node MetricRegistrySolr's default query parser, a schema-driven superset of the classic lucene query parser.
This class is overridden by QueryParser in QueryParser.jj and acts to separate the majority of
the Java code from the .jj grammar file.
Identifies the list of all known "magic fields" that trigger special parsing behavior
Query strategy when analyzed query terms overlap the same position (ie synonyms) consider if
pants and khakis are query time synonyms
Container for a request to execute a query.
Base implementation of
SolrQueryRequest that provides some convenience methods for
accessing parameters, and manages an IndexSearcher reference.SolrQueryResponse is used by a query handler to return the response to a query
request.Implementation of
ScheduledReporter that reports metrics from selected registries and
sends them periodically as update requests to a selected Solr collection and to a configured
handler.Builder for the
SolrReporter class.Specification of what registries and what metrics to send.
A JAX-RS request filter that blocks or allows requests based on the authorization plugin
configured in security.json.
Implementations of
SolrRequestHandler are called to handle query requests.Information about the Solr request/response held in a
ThreadLocal.The default implementation of return fields parsing for Solr.
Detects whether a query can be run using a standard Lucene
IndexSearcherMarker interface indicating that the tagged class assumes access to
SolrIndexSearcher
functionality and cannot be used by a vanilla Lucene IndexSearcherMetrics reporter that wraps
Slf4jReporter.This class provides functionality required to handle the data files corresponding to Solr
snapshots.
This class is responsible to manage the persistent snapshots meta-data for the Solr indexes.
A class defining the meta-data for a specific snapshot.
Refer to https://solr.apache.org/guide/solr/latest/query-guide/spell-checking.html
for more details.
Responsible for loading the lookup and dictionary Implementations specified by the SolrConfig.
Loads
solr.xml.SortableTextField is a specialized form of TextField that supports Sorting
and ValueSource functions, using docValues built from the first
maxCharsForDocValues characters of the original (pre-analyzed) String values of this
field.A simple sorted int[] array implementation of
DocSet, good for small sets.A
MergePolicyFactory for SortingMergePolicy objects.SortSpec encapsulates a Lucene Sort and a count of the number of documents to return.
Creates a spatial Filter based on the type of spatial point used.
A 2D spatial faceting summary of a rectangular region.
Indicate that the implementing class is capable of generating a Query against spatial resources.
Utility methods pertaining to spatial.
A SearchComponent implementation which provides support for spell checking and suggestions using
the Lucene contributed SpellChecker.
Converts the query string to a Collection of Lucene tokens using a regular expression.
Implementations of SolrSpellChecker must return suggestions as SpellResult instance.
V2 API for splitting a single core into multiple pieces
A split index command encapsulated in an object.
V2 API for splitting an existing shard up into multiple pieces.
SolrCloud logic for splitting a shard.
While not strictly a distance, the Sq.
Dedicated object to handle Solr configurations
Interface for different source of SSL configurations.
Class responsible to build SSL credential providers
Directory provider which mimics original Solr
FSDirectory based
behavior.Default IndexReaderFactory implementation.
Deprecated.
Handles programmatic modification of logging during startup
Used to hold statistics about some SolrCloud operations.
This class represents a cache of global document frequency information for selected terms.
Stats component calculates simple statistics on numeric field values
Models all of the information associated with a single
StatsParams.STATS_FIELD instance.Helper Struct for parsing and encapsulating all of the options relaed to building a
HLLAn enumeration representing the sumer set of all possible stat values that can be computed.
The purpose of this class is only to provide two pieces of information necessary to create
Weight from a Query, that is TermStatistics for a term and CollectionStatistics for the whole collection.Various utilities for de/serialization of term stats and collection stats.
StatsValue defines the interface for the collection of statistical values about fields and
facets.
Factory class for creating instance of
StatsValuesConcrete implementation for processing the stored field values from shard responses.
Solr Request Handler for streaming data.
Simple class to help with parsing a string.
This transformer executes subquery per every result document.
An implementation of
Predicate which returns true if the BytesRef contains a given
substring.SuggestComponent: interacts with multiple
SolrSuggester to serve up suggestions
Responsible for routing commands and queries to the appropriate SolrSuggester and for
initializing them as specified by SolrConfigEncapsulates the inputs required to be passed on to the underlying suggester in
SolrSuggesterEncapsulates the results returned by the suggester in
SolrSuggesterPasses the entire query string to the configured analyzer as-is.
Plugin for lucene Surround query parser, bringing SpanQuery support to Solr.
Factory for
SweetSpotSimilarity.A QParserPlugin that acts like a "switch/case" statement.
V2 API implementation for triggering a shard-sync operation within a particular collection and
shard.
Simple checked exception for parsing errors
A synthetic core that is created only in memory and not registered against Zookeeper.
System property based SSL configuration provider
This is a helper class to support resolving of XIncludes or other hrefs inside XML files on top
of a
ResourceLoader.This handler returns system info
Base response writer for table-oriented data
Tags maximum string of words in a corpus.
Scans posted text, looking for matching strings in the Solr index.
Implementation of the
TaggingAttributeThis is a Tag -- a startOffset, endOffset and value.
Abstract class which serves as the root of all task managing handlers
Adds new fields to documents based on a template pattern specified via Template.field request
parameters (multi-valued) or 'field' value specified in initArgs.
Create a single term query from the input value equivalent to readableToIndexed().
Return TermEnum information, useful for things like auto suggest.
Comparator for
TermsResponse.Term sorting This
sorts term by frequency in descending orderFinds documents whose specified field has any of the specified values.
Modifiable version of
TermStatistics useful for aggregation of per-shard stats.Return term vectors for the documents in a query result set.
Allows random faults to be injected in running code during test runs.
TextField is the basic type for configurable text analysis.Returns an AnalyticsQuery implementation that performs one Gradient Descent iteration of a result
set to train a logistic regression model
This implementation is copied from Apache Nutch.
Base class for text-oriented response writers.
Allows tracking information about the current thread using the JVM's built-in management bean
ThreadMXBean.A
MergePolicyFactory for TieredMergePolicy objects.Enforces a wall clock based timeout on a given SolrQueryRequest.
Timeout tool to ease checking time left, time elapsed, and waiting on a condition.
Holds configuration for a routed alias, and some common code and constants.
An update processor that adds a newly generated
Date value of "NOW" to any document
being added that does not already have a value in the specified field.Simple utilities for working with TimeZones
Describes the input token stream.
Deprecated.
An analyzer that uses a tokenizer and a list of token filters to create a TokenStream.
Token Manager Error.
Suppresses errors for individual add/delete commands within a single request.
Suppresses errors for individual add/delete commands within a single request.
An implementation of this class is specified when executing
ToolBase to access
environment specific methods (mostly to differentiate test from non-test executions for now).TopDocsSlice implements DocList based off provided TopDocs.Defines all collectors for retrieving the second phase and how to handle the collector result.
Implementation for transforming
TopGroups and TopDocs into a NamedList
structure and vice versa.Concrete implementation of
ShardRequestFactory that creates ShardRequest
instances for getting the top groups from all shards.Concrete implementation for merging
TopGroups instances from shard responses.JoinQuery implementation using global (top-level) DocValues ordinals to efficiently
compare values in the "from" and "to" fields.Produces an OpenTracing
Tracer from configuration.Utilities for distributed tracing.
Log Format: List{Operation, Version, ...} ADD, VERSION, DOC DELETE, VERSION, ID_BYTES
DELETE_BY_QUERY, VERSION, String
Opens
TransactionLog.ChannelFastInputStream from FileChannel.Opens
OutputStream from FileChannel.New instance for each request
The
TransformerFactory.FieldRenamer interface should be implemented by any TransformerFactory
capable of generating transformers that might rename fields, and should implement TransformerFactory.FieldRenamer.create(String, SolrParams, SolrQueryRequest, Map, Set) in place of TransformerFactory.create(String, SolrParams, SolrQueryRequest) (with the latter method overridden to throw UnsupportedOperationException).Deprecated.
Deprecated.
Deprecated.
Deprecated.
Trie fields are deprecated as of Solr 7.0
Deprecated.
Trie fields are deprecated as of Solr 7.0
Deprecated.
Trie fields are deprecated as of Solr 7.0
Deprecated.
Trie fields are deprecated as of Solr 7.0
Deprecated.
Trie fields are deprecated as of Solr 7.0
Deprecated.
Trie fields are deprecated as of Solr 7.0
Trims leading and trailing whitespace from any CharSequence values found in fields matching the
specified conditions and returns the resulting String.
Truncates any CharSequence values found in fields matching the specified conditions to a maximum
character length.
Factory for
TSTLookupHighlighter impl that uses
UnifiedHighlighterFinal form of the un-inverted field: Each document points to a list of term numbers that are
contained in that document.
Base accumulator for
UnInvertedFieldA FilterReader that exposes indexed values as if they also had docvalues.
Return information about the backing cache
Specifies the type of uninversion to apply for the field.
Removes duplicate values found in fields matching the specified conditions.
V2 API implementation for unloading a Solr core.
Supports updating ACL for a path in ZK
All v2 APIs that share a prefix of /update
An index update command encapsulated in an object (Command pattern)
UpdateHandler handles requests to change the index (adds, deletes, commits,
optimizes, etc).Locks associated with updates in connection with the
UpdateLog.This holds references to the transaction logs.
Holds the query and the version for a DeleteByQuery command
UpdateHandler that uses content-type to pick the right Loader
This is a good place for subclassed update handlers to process the document before it is indexed.
Manages a chain of UpdateRequestProcessorFactories.
A factory to generate an UpdateRequestProcessor for each request.
A marker interface for UpdateRequestProcessorFactory implementations indicating that the
factory should be used even if the update.distrib parameter would otherwise cause it to not be
run.
Implements the UPGRADEINDEX CoreAdmin action, which upgrades an existing core's index in-place by
reindexing documents from segments belonging to older Lucene versions, so that they get written
into latest version segments.
A
MergePolicyFactory for UpgradeIndexMergePolicy objects.Deprecated.
Please use
ClusterFileStoreApis.Update processor which examines a URL and outputs to various other fields characteristics of that
URL, including length, number of path levels, whether it is a top level URL (levels==0), whether
it looks like a landing/index page, a canonical representation of the URL (e.g.
Creates URLClassifyProcessor
This FieldType accepts UUID string values, as well as the special value of "NEW" which triggers
generation of a new random UUID.
An update processor that adds a newly generated
UUID value to any document being
added that does not already have a value in the specified field.Utilities helpful for common V2 API declaration tasks.
An extension of
UpdateRequestHandler used solely to register the v2 /update APIsAdd values from a ValueSource (function query etc)
Fake scorer for a single document
A factory parsing arguments (from
FunctionQParser) into a real function whose results are
emitted from a ValueSource.RangeFilter over a ValueSource.
Calculate the p-norm for a Vector.
A neural query parser to run min-similarity search on Dense Vector fields.
This class provides implementation for two variants for parsing function query vectorSimilarity
which is used to calculate the similarity between two vectors.
Interface used to pass verified user roles in a Principal object.
Related to the
_version_ field, in connection with the UpdateLog.Factory for
WFSTCompletionLookupA spellchecker that breaks and combines words.
Specify a value on the "breakSuggestionTieBreaker" parameter.
A simple query that wraps another query and implements ExtendedQuery.
A
MergePolicyFactory for wrapping additional factories.Wrapper around an XML DOM object to provide convenient accessors to it.
Corrects offsets to adjust for XML formatted data.
The
XmlQParserPlugin extends the QParserPlugin and supports the creation of
queries from XML.The plugin configurations are stored and retrieved from the ZooKeeper cluster properties, stored
at the
ZkStateReader.CONTAINER_PLUGINS location This supports mutable configurations, and
management via the /cluster/plugin APIsSolrCloud Zookeeper ConfigSetService impl.
Used by
CoreContainer to hold ZooKeeper / SolrCloud info, especially ZkController.Handle ZooKeeper interactions.
Thrown during pre register process if the replica is not present in clusterstate
A distributed lock implementation using Zookeeper "directory" nodes created within a collection
znode hierarchy, for use with the distributed Collection API implementation.
A distributed lock implementation using Zookeeper "directory" nodes created within a collection
znode hierarchy, for use with the distributed Collection API implementation.
A ZK-based distributed queue.
Keeps a ManagedIndexSchema up-to-date when changes are made to the serialized managed schema in
ZooKeeper
Watches for schema changes and triggers updates in the ZkIndexSchemaReader.
Class used for interact with a ZK term node.
ResourceLoader that works with ZooKeeper.
ZkStateWriter is responsible for writing updates to the cluster state stored in ZooKeeper for
collections each of which gets their own individual state.json in ZK.
Supports zk help information in the bin/solr script.
Zookeeper Info
v2 API definition exposing read-content in Zookeeper.
Zookeeper Status handler, talks to ZK using sockets and four-letter words
FileStore.