All Classes and Interfaces (Lucene 10.5.1 queryparser API)
Description: class index

# All Classes and Interfaces

Class
Description
AbstractQueryConfig
This class is the base of `QueryConfigHandler` and `FieldConfig`.
AbstractRangeQueryNode<T>
This class should be extended by nodes intending to represent range queries.
After
Node that represents `Intervals.after(IntervalsSource, IntervalsSource)`.
AllowLeadingWildcardProcessor
This processor verifies if `StandardQueryConfigHandler.ConfigurationKeys.ALLOW_LEADING_WILDCARD` is defined in the `QueryConfigHandler`.
AnalyzedText
Node that represents `Intervals.analyzedText(String, Analyzer, String, int, boolean)`.
AnalyzerQueryNodeProcessor
This processor verifies if `StandardQueryConfigHandler.ConfigurationKeys.ANALYZER` is defined in the `QueryConfigHandler`.
AndQuery
Factory for conjunctions
AndQueryNode
A `AndQueryNode` represents an AND boolean operation performed on a list of nodes.
AnyQueryNode
A `AnyQueryNode` represents an ANY operator performed on a list of nodes.
AnyQueryNodeBuilder
Builds a BooleanQuery of SHOULD clauses, possibly with some minimum number to match.
AtLeast
Node that represents `Intervals.atLeast(int, IntervalsSource...)`.
BasicQueryFactory
Factory for creating basic term queries
Before
Node that represents `Intervals.before(IntervalsSource, IntervalsSource)`.
BooleanModifierNode
A `BooleanModifierNode` has the same behaviour as `ModifierQueryNode`, it only indicates that this modifier was added by `BooleanQuery2ModifierNodeProcessor` and not by the user.
BooleanModifiersQueryNodeProcessor
This processor is used to apply the correct `ModifierQueryNode` to `BooleanQueryNode`s children.
BooleanQuery2ModifierNodeProcessor
This processor is used to apply the correct `ModifierQueryNode` to `BooleanQueryNode`s children.
BooleanQueryBuilder
Builder for `BooleanQuery`
BooleanQueryNode
A `BooleanQueryNode` represents a list of elements which do not have an explicit boolean operator defined between them.
BooleanQueryNodeBuilder
Builds a `BooleanQuery` object from a `BooleanQueryNode` object.
BooleanSingleChildOptimizationQueryNodeProcessor
This processor removes every `BooleanQueryNode` that contains only one child and returns this child.
BoostingTermBuilder
Builder for `PayloadScoreQuery`
BoostQueryNode
A `BoostQueryNode` boosts the QueryNode tree which is under this node.
BoostQueryNodeBuilder
This builder basically reads the `Query` object set on the `BoostQueryNode` child using `QueryTreeBuilder.QUERY_TREE_BUILDER_TAGID` and applies the boost value defined in the `BoostQueryNode`.
BoostQueryNodeProcessor
This processor iterates the query node tree looking for every `FieldableNode` that has `StandardQueryConfigHandler.ConfigurationKeys.BOOST` in its config.
CharStream
This interface describes a character stream that maintains line and column number positions of the characters.
CommonQueryParserConfiguration
Configuration options common across queryparser implementations.
ComplexPhraseQueryParser
QueryParser which permits complex phrase query syntax eg "(john jon jonathan~) peters*".
ComposedQuery
Base class for composite queries (such as AND/OR/NOT)
ConfigurationKey<T>
An instance of this class represents a key that is used to retrieve a value from `AbstractQueryConfig`.
ConstantScoreQueryBuilder
Builder for `ConstantScoreQuery`
ContainedBy
Node that represents `Intervals.containedBy(IntervalsSource, IntervalsSource)`.
Containing
Node that represents `Intervals.containing(IntervalsSource, IntervalsSource)`.
CoreParser
Assembles a QueryBuilder which uses only core Lucene Query objects
CorePlusExtensionsParser
Assembles a QueryBuilder which uses Query objects from Lucene's `sandbox` and `queries` modules in addition to core queries.
CorePlusQueriesParser
Assembles a QueryBuilder which uses Query objects from Lucene's `queries` module in addition to core queries.
DefaultPhraseSlopQueryNodeProcessor
This processor verifies if `StandardQueryConfigHandler.ConfigurationKeys.PHRASE_SLOP` is defined in the `QueryConfigHandler`.
DeletedQueryNode
A `DeletedQueryNode` represents a node that was deleted from the query node tree.
DisjunctionMaxQueryBuilder
Builder for `DisjunctionMaxQuery`
DistanceQuery
Factory for NEAR queries
DistanceSubQuery
Interface for queries that can be nested as subqueries into a span near.
DOMUtils
Helper methods for parsing XML.
DummyQueryNodeBuilder
This builder does nothing.
EscapeQuerySyntax
A parser needs to implement `EscapeQuerySyntax` to allow the QueryNode to escape the queries, when the toQueryString method is called.
EscapeQuerySyntax.Type
Type of escaping: String for escaping syntax, NORMAL for escaping reserved words (like AND) in terms
EscapeQuerySyntaxImpl
Implementation of `EscapeQuerySyntax` for the standard lucene syntax.
Extend
Node that represents `Intervals.extend(IntervalsSource, int, int)`.
ExtendableQueryParser
The `ExtendableQueryParser` enables arbitrary query parser extension based on a customizable field naming scheme.
ExtensionQuery
`ExtensionQuery` holds all query components extracted from the original query string like the query field and the extension query string.
Extensions
The `Extensions` class represents an extension mapping to associate `ParserExtension` instances with extension keys.
Extensions.Pair<Cur,Cud>
This class represents a generic pair.
FastCharStream
An efficient implementation of JavaCC's CharStream interface.
FieldableNode
A query node implements `FieldableNode` interface to indicate that its children and itself are associated to a specific field.
FieldBoostMapFCListener
This listener listens for every field configuration request and assign a `StandardQueryConfigHandler.ConfigurationKeys.BOOST` to the equivalent `FieldConfig` based on a defined map: fieldName -> boostValue stored in `StandardQueryConfigHandler.ConfigurationKeys.FIELD_BOOST_MAP`.
FieldConfig
This class represents a field configuration.
FieldConfigListener
This interface should be implemented by classes that wants to listen for field configuration requests.
FieldDateResolutionFCListener
This listener listens for every field configuration request and assign a `StandardQueryConfigHandler.ConfigurationKeys.DATE_RESOLUTION` to the equivalent `FieldConfig` based on a defined map: fieldName -> `DateTools.Resolution` stored in `StandardQueryConfigHandler.ConfigurationKeys.FIELD_DATE_RESOLUTION_MAP`.
FieldQueryNode
A `FieldQueryNode` represents a element that contains field/text tuple
FieldQueryNodeBuilder
Builds a `TermQuery` object from a `FieldQueryNode` object.
FieldsQuery
Forms an OR query of the provided query across multiple fields.
FieldValuePairQueryNode<T>
This interface should be implemented by `QueryNode` that holds a field and an arbitrary value.
FuzzyConfig
Configuration parameters for `FuzzyQuery`s
FuzzyLikeThisQueryBuilder
Builder for `FuzzyLikeThisQuery`
FuzzyQueryNode
A `FuzzyQueryNode` represents a element that contains field/text/similarity tuple
FuzzyQueryNodeBuilder
Builds a `FuzzyQuery` object from a `FuzzyQueryNode` object.
FuzzyQueryNodeProcessor
This processor iterates the query node tree looking for every `FuzzyQueryNode`, when this kind of node is found, it checks on the query configuration for `StandardQueryConfigHandler.ConfigurationKeys.FUZZY_CONFIG`, gets the fuzzy prefix length and default similarity from it and set to the fuzzy node.
FuzzyTerm
An interval function equivalent to `FuzzyQuery`.
GroupQueryNode
A `GroupQueryNode` represents a location where the original user typed real parenthesis on the query string.
GroupQueryNodeBuilder
Builds no object, it only returns the `Query` object set on the `GroupQueryNode` object using a `QueryTreeBuilder.QUERY_TREE_BUILDER_TAGID` tag.
IntervalFunction
Representation of an interval function that can be converted to `IntervalsSource`.
IntervalQueryNode
Node that represents an interval function.
IntervalQueryNodeBuilder
Builds a `Query` from an `IntervalQueryNode`.
IntervalQueryNodeProcessor
This processor makes sure that `StandardQueryConfigHandler.ConfigurationKeys.ANALYZER` is defined in the `QueryConfigHandler` and injects this analyzer into `IntervalQueryNode`s.
LikeThisQueryBuilder
Builder for `MoreLikeThisQuery`
MatchAllDocsQueryBuilder
Builder for `MatchAllDocsQuery`
MatchAllDocsQueryNode
A `MatchAllDocsQueryNode` indicates that a query node tree or subtree will match all documents if executed in the index.
MatchAllDocsQueryNodeBuilder
Builds a `MatchAllDocsQuery` object from a `MatchAllDocsQueryNode` object.
MatchAllDocsQueryNodeProcessor
This processor converts every `WildcardQueryNode` that is "*:*" to `MatchAllDocsQueryNode`.
MatchNoDocsQueryNode
A `MatchNoDocsQueryNode` indicates that a query node tree or subtree will not match any documents if executed in the index.
MatchNoDocsQueryNodeBuilder
Builds a `MatchNoDocsQuery` object from a `MatchNoDocsQueryNode` object.
MaxGaps
Node that represents `Intervals.maxgaps(int, IntervalsSource)`.
MaxWidth
Node that represents `Intervals.maxwidth(int, IntervalsSource)`.
Message
Message Interface for a lazy loading.
MessageImpl
Default implementation of Message interface.
MinShouldMatchNode
Node that represents a minimum-should-match restriction on a `GroupQueryNode`.
MinShouldMatchNodeBuilder
Builds a `BooleanQuery` from a `MinShouldMatchNode`.
ModifierQueryNode
A `ModifierQueryNode` indicates the modifier value (+,-,?,NONE) for each term on the query string.
ModifierQueryNode.Modifier
Modifier type: such as required (REQ), prohibited (NOT)
ModifierQueryNodeBuilder
Builds no object, it only returns the `Query` object set on the `ModifierQueryNode` object using a `QueryTreeBuilder.QUERY_TREE_BUILDER_TAGID` tag.
MultiFieldQueryNodeProcessor
This processor is used to expand terms so the query looks for the same term in different fields.
MultiFieldQueryParser
A QueryParser which constructs queries to search multiple fields.
MultiPhraseQueryNode
A `MultiPhraseQueryNode` indicates that its children should be used to build a `MultiPhraseQuery` instead of `PhraseQuery`.
MultiPhraseQueryNodeBuilder
Builds a `MultiPhraseQuery` object from a `MultiPhraseQueryNode` object.
MultiTermRewriteMethodProcessor
This processor instates the default `MultiTermQuery.RewriteMethod`, `MultiTermQuery.CONSTANT_SCORE_BLENDED_REWRITE`, for multi-term query nodes.
NLS
MessageBundles classes extend this class, to implement a bundle.
NLSException
Interface that exceptions should implement to support lazy loading of messages.
NoChildOptimizationQueryNodeProcessor
A `NoChildOptimizationQueryNodeProcessor` removes every BooleanQueryNode, BoostQueryNode, TokenizedPhraseQueryNode or ModifierQueryNode that do not have a valid children.
NonOverlapping
Node that represents `Intervals.nonOverlapping(IntervalsSource, IntervalsSource)` .
NotContainedBy
Node that represents `Intervals.notContainedBy(IntervalsSource, IntervalsSource)`.
NotContaining
Node that represents `Intervals.notContaining(IntervalsSource, IntervalsSource)`.
NoTokenFoundQueryNode
A `NoTokenFoundQueryNode` is used if a term is convert into no tokens by the tokenizer/lemmatizer/analyzer (null).
NotQuery
Factory for prohibited clauses
NotWithin
Node that represents `Intervals.notWithin(IntervalsSource, int, IntervalsSource)`.
NumberDateFormat
This `Format` parses `Long` into date strings and vice-versa.
OpaqueQueryNode
A `OpaqueQueryNode` is used for specify values that are not supposed to be parsed by the parser.
OpenRangeQueryNodeProcessor
Processes `TermRangeQuery`s with open ranges.
Or
Node that represents `Intervals.or(IntervalsSource...)`.
Ordered
Node that represents `Intervals.ordered(IntervalsSource...)`.
OrQuery
Factory for disjunctions
OrQueryNode
A `OrQueryNode` represents an OR boolean operation performed on a list of nodes.
Overlapping
Node that represents `Intervals.overlapping(IntervalsSource, IntervalsSource)`.
ParseException
This exception is thrown when parse errors are encountered.
ParseException
This exception is thrown when parse errors are encountered.
ParseException
This exception is thrown when parse errors are encountered.
ParserException
Thrown when the xml queryparser encounters invalid syntax/configuration.
ParserExtension
This class represents an extension base class to the Lucene standard `QueryParser`.
PathQueryNode
A `PathQueryNode` is used to store queries like /company/USA/California /product/shoes/brown.
PathQueryNode.QueryText
Term text with a beginning and end position
Phrase
Node that represents `Intervals.phrase(String...)`.
PhraseQueryNodeBuilder
Builds a `PhraseQuery` object from a `TokenizedPhraseQueryNode` object.
PhraseSlopQueryNode
Query node for `PhraseQuery`'s slop factor.
PhraseSlopQueryNodeProcessor
This processor removes invalid `SlopQueryNode` objects in the query node tree.
PointQueryNode
This query node represents a field query that holds a point value.
PointQueryNodeProcessor
This processor is used to convert `FieldQueryNode`s to `PointRangeQueryNode`s.
PointRangeQueryBuilder
Creates a range query across 1D `PointValues`.
PointRangeQueryNode
This query node represents a range query composed by `PointQueryNode` bounds, which means the bound values are `Number`s.
PointRangeQueryNodeBuilder
Builds `PointValues` range queries out of `PointRangeQueryNode`s.
PointRangeQueryNodeProcessor
This processor is used to convert `TermRangeQueryNode`s to `PointRangeQueryNode`s.
PointsConfig
This class holds the configuration used to parse numeric queries and create `PointValues` queries.
PointsConfigListener
This listener is used to listen to `FieldConfig` requests in `QueryConfigHandler` and add `StandardQueryConfigHandler.ConfigurationKeys.POINTS_CONFIG` based on the `StandardQueryConfigHandler.ConfigurationKeys.POINTS_CONFIG_MAP` set in the `QueryConfigHandler`.
PrecedenceQueryNodeProcessorPipeline
This processor pipeline extends `StandardQueryNodeProcessorPipeline` and enables boolean precedence on it.
PrecedenceQueryParser
This query parser works exactly as the standard query parser ( `StandardQueryParser` ), except that it respect the boolean precedence, so <a AND b OR c AND d> is parsed to <(+a +b) (+c +d)> instead of <+a +b +c +d>.
PrefixWildcardQueryNode
A `PrefixWildcardQueryNode` represents wildcardquery that matches abc* or *.
PrefixWildcardQueryNodeBuilder
Builds a `PrefixQuery` object from a `PrefixWildcardQueryNode` object.
ProximityQueryNode
A `ProximityQueryNode` represents a query where the terms should meet specific distance conditions.
ProximityQueryNode.ProximityType
utility class containing the distance condition and number
ProximityQueryNode.Type
Distance condition: PARAGRAPH, SENTENCE, or NUMBER
QueryBuilder
This interface is used by implementors classes that builds some kind of object from a query tree.
QueryBuilder
Implemented by objects that produce Lucene Query objects from XML streams.
QueryBuilderFactory
Factory for `QueryBuilder`
QueryConfigHandler
This class can be used to hold any query configuration and no field configuration.
QueryNode
A `QueryNode` is a interface implemented by all nodes on a QueryNode tree.
QueryNodeError
Error class with NLS support
QueryNodeException
This exception should be thrown if something wrong happens when dealing with `QueryNode`s.
QueryNodeImpl
A `QueryNodeImpl` is the default implementation of the interface `QueryNode`
QueryNodeOperation
Allow joining 2 QueryNode Trees, into one.
QueryNodeParseException
This should be thrown when an exception happens during the query parsing from string to the query node tree.
QueryNodeProcessor
A `QueryNodeProcessor` is an interface for classes that process a `QueryNode` tree.
QueryNodeProcessorImpl
This is a default implementation for the `QueryNodeProcessor` interface, it's an abstract class, so it should be extended by classes that want to process a `QueryNode` tree.
QueryNodeProcessorPipeline
A `QueryNodeProcessorPipeline` class should be used to build a query node processor pipeline.
QueryParser
This class is generated by JavaCC.
QueryParser
This class is generated by JavaCC.
QueryParser.Operator
The default operator for parsing queries.
QueryParserBase
This class is overridden by QueryParser in QueryParser.jj and acts to separate the majority of the Java code from the .jj grammar file.
QueryParserConstants
Token literal values and constants.
QueryParserConstants
Token literal values and constants.
QueryParserHelper
This class is a helper for the query parser framework, it does all the three query parser phrases at once: text parsing, query processing and query building.
QueryParserMessages
Flexible Query Parser message bundle class
QueryParserTokenManager
Token Manager.
QueryParserTokenManager
Token Manager.
QueryParserUtil
This class defines utility methods to (help) parse query strings into `Query` objects.
QueryTreeBuilder
This class should be used when there is a builder for each type of node.
QuotedFieldQueryNode
A `QuotedFieldQueryNode` represents phrase query.
RangeQueryBuilder
Builder for `TermRangeQuery`
RangeQueryNode<T>
This interface should be implemented by a `QueryNode` that represents some kind of range query.
RegexpQueryNode
A `RegexpQueryNode` represents `RegexpQuery` query Examples: /[a-z]|[0-9]/
RegexpQueryNodeBuilder
Builds a `RegexpQuery` object from a `RegexpQueryNode` object.
RegexpQueryNodeProcessor
Processor for Regexp queries.
RemoveDeletedQueryNodesProcessor
A `QueryNodeProcessorPipeline` class removes every instance of `DeletedQueryNode` from a query node tree.
RemoveEmptyNonLeafQueryNodeProcessor
This processor removes every `QueryNode` that is not a leaf and has not children.
SimpleQueryParser
SimpleQueryParser is used to parse human readable query syntax.
SimpleTerm
Base class for queries that expand to sets of simple terms.
SimpleTerm.MatchingTermVisitor
Callback to visit each matching term during "rewrite" in `SimpleTerm.MatchingTermVisitor.visitMatchingTerm(Term)`
SlopQueryNode
A `SlopQueryNode` represents phrase query with a slop.
SlopQueryNodeBuilder
This builder basically reads the `Query` object set on the `SlopQueryNode` child using `QueryTreeBuilder.QUERY_TREE_BUILDER_TAGID` and applies the slop value defined in the `SlopQueryNode`.
SpanBuilderBase
Base class for building `SpanQuery`s
SpanFirstBuilder
Builder for `SpanFirstQuery`
SpanNearBuilder
Builder for `SpanNearQuery`
SpanNearClauseFactory
Factory for `SpanOrQuery`
SpanNotBuilder
Builder for `SpanNotQuery`
SpanOrBuilder
Builder for `SpanOrQuery`
SpanOrTermsBuilder
Builder that analyzes the text into a `SpanOrQuery`
SpanPositionRangeBuilder
Builder for `SpanPositionRangeQuery`
SpanQueryBuilder
Interface for retrieving a `SpanQuery`.
SpanQueryBuilderFactory
Factory for `SpanQueryBuilder`s
SpanTermBuilder
Builder for `SpanTermQuery`
SrndPrefixQuery
Query that matches String prefixes
SrndQuery
Lowest level base class for surround queries
SrndTermQuery
Simple single-term clause
SrndTruncQuery
Query that matches wildcards
StandardQueryBuilder
This interface should be implemented by every class that wants to build `Query` objects from `QueryNode` objects.
StandardQueryConfigHandler
This query configuration handler is used for almost every processor defined in the `StandardQueryNodeProcessorPipeline` processor pipeline.
StandardQueryConfigHandler.ConfigurationKeys
Class holding keys for StandardQueryNodeProcessorPipeline options.
StandardQueryConfigHandler.Operator
Boolean Operator: AND or OR
StandardQueryNodeProcessorPipeline
This pipeline has all the processors needed to process a query node tree, generated by `StandardSyntaxParser`, already assembled.
StandardQueryParser
The `StandardQueryParser` is a pre-assembled query parser that supports most features of the classic Lucene query parser, allows dynamic configuration of some of its features (like multi-field expansion or wildcard query restrictions) and adds support for new query types and expressions.
StandardQueryTreeBuilder
This query tree builder only defines the necessary map to build a `Query` tree object.
StandardSyntaxParser
Parser for the standard Lucene syntax
StandardSyntaxParserConstants
Token literal values and constants.
StandardSyntaxParserTokenManager
Token Manager.
StringUtils
String manipulation routines
SynonymQueryNode
`QueryNode` for clauses that are synonym of each other.
SynonymQueryNodeBuilder
Builder for `SynonymQueryNode`.
SyntaxParser
A parser needs to implement `SyntaxParser` interface
TermQueryBuilder
Builder for `TermQuery`
TermRangeQueryNode
This query node represents a range query composed by `FieldQueryNode` bounds, which means the bound values are strings.
TermRangeQueryNodeBuilder
Builds a `TermRangeQuery` object from a `TermRangeQueryNode` object.
TermRangeQueryNodeProcessor
This processors process `TermRangeQueryNode`s.
TermsQueryBuilder
Builds a BooleanQuery from all of the terms found in the XML element using the choice of analyzer
TextableQueryNode
Interface for a node that has text as a `CharSequence`
Token
Describes the input token stream.
Token
Describes the input token stream.
Token
Describes the input token stream.
TokenizedPhraseQueryNode
A `TokenizedPhraseQueryNode` represents a node created by a code that tokenizes/lemmatizes/analyzes.
TokenMgrError
Token Manager Error.
TokenMgrError
Token Manager Error.
TokenMgrError
Token Manager Error.
TooManyBasicQueries
Exception thrown when `BasicQueryFactory` would exceed the limit of query clauses.
UnescapedCharSequence
CharsSequence with escaped chars information.
Unordered
Node that represents `Intervals.unordered(IntervalsSource...)`.
UnorderedNoOverlaps
Node that represents `Intervals.unorderedNoOverlaps(IntervalsSource, IntervalsSource)`.
UserInputQueryBuilder
UserInputQueryBuilder uses 1 of 2 strategies for thread-safe parsing: 1) Synchronizing access to "parse" calls on a previously supplied QueryParser or..
ValueQueryNode<T>
This interface should be implemented by `QueryNode` that holds an arbitrary value.
Wildcard
Node that represents `Intervals.wildcard(BytesRef)`.
WildcardQueryNode
A `WildcardQueryNode` represents wildcard query This does not apply to phrases.
WildcardQueryNodeBuilder
Builds a `WildcardQuery` object from a `WildcardQueryNode` object.
WildcardQueryNodeProcessor
The `StandardSyntaxParser` creates `PrefixWildcardQueryNode` nodes which have values containing the prefixed wildcard.
Within
Node that represents `Intervals.within(IntervalsSource, int, IntervalsSource)`.