All Classes and Interfaces
Class
Description
This class is the base of
QueryConfigHandler and FieldConfig.This class should be extended by nodes intending to represent range queries.
Node that represents
Intervals.after(IntervalsSource, IntervalsSource).This processor verifies if
StandardQueryConfigHandler.ConfigurationKeys.ALLOW_LEADING_WILDCARD is defined in the
QueryConfigHandler.Node that represents
Intervals.analyzedText(String, Analyzer, String, int, boolean).This processor verifies if
StandardQueryConfigHandler.ConfigurationKeys.ANALYZER is defined in the QueryConfigHandler.Factory for conjunctions
A
AndQueryNode represents an AND boolean operation performed on a list of nodes.A
AnyQueryNode represents an ANY operator performed on a list of nodes.Builds a BooleanQuery of SHOULD clauses, possibly with some minimum number to match.
Node that represents
Intervals.atLeast(int, IntervalsSource...).Factory for creating basic term queries
Node that represents
Intervals.before(IntervalsSource, IntervalsSource).A
BooleanModifierNode has the same behaviour as ModifierQueryNode, it only
indicates that this modifier was added by BooleanQuery2ModifierNodeProcessor and not by
the user.This processor is used to apply the correct
ModifierQueryNode to BooleanQueryNodes children.This processor is used to apply the correct
ModifierQueryNode to BooleanQueryNodes children.Builder for
BooleanQueryA
BooleanQueryNode represents a list of elements which do not have an explicit boolean
operator defined between them.Builds a
BooleanQuery object from a BooleanQueryNode object.This processor removes every
BooleanQueryNode that contains only one child and returns
this child.Builder for
PayloadScoreQueryA
BoostQueryNode boosts the QueryNode tree which is under this node.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.This processor iterates the query node tree looking for every
FieldableNode that has
StandardQueryConfigHandler.ConfigurationKeys.BOOST in its config.This interface describes a character stream that maintains line and column number positions of
the characters.
Configuration options common across queryparser implementations.
QueryParser which permits complex phrase query syntax eg "(john jon jonathan~) peters*".
Base class for composite queries (such as AND/OR/NOT)
An instance of this class represents a key that is used to retrieve a value from
AbstractQueryConfig.Builder for
ConstantScoreQueryNode that represents
Intervals.containedBy(IntervalsSource, IntervalsSource).Node that represents
Intervals.containing(IntervalsSource, IntervalsSource).Assembles a QueryBuilder which uses only core Lucene Query objects
Assembles a QueryBuilder which uses Query objects from Lucene's
sandbox and
queries modules in addition to core queries.Assembles a QueryBuilder which uses Query objects from Lucene's
queries module in
addition to core queries.This processor verifies if
StandardQueryConfigHandler.ConfigurationKeys.PHRASE_SLOP is defined in the QueryConfigHandler.A
DeletedQueryNode represents a node that was deleted from the query node tree.Builder for
DisjunctionMaxQueryFactory for NEAR queries
Interface for queries that can be nested as subqueries into a span near.
Helper methods for parsing XML
This builder does nothing.
A parser needs to implement
EscapeQuerySyntax to allow the QueryNode to escape the
queries, when the toQueryString method is called.Type of escaping: String for escaping syntax, NORMAL for escaping reserved words (like AND) in
terms
Implementation of
EscapeQuerySyntax for the standard lucene syntax.Node that represents
Intervals.extend(IntervalsSource, int, int).The
ExtendableQueryParser enables arbitrary query parser extension based on a
customizable field naming scheme.ExtensionQuery holds all query components extracted from the original query string like
the query field and the extension query string.The
Extensions class represents an extension mapping to associate ParserExtension
instances with extension keys.This class represents a generic pair.
An efficient implementation of JavaCC's CharStream interface.
A query node implements
FieldableNode interface to indicate that its children and itself
are associated to a specific field.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.This class represents a field configuration.
This interface should be implemented by classes that wants to listen for field configuration
requests.
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.A
FieldQueryNode represents a element that contains field/text tupleBuilds a
TermQuery object from a FieldQueryNode object.Forms an OR query of the provided query across multiple fields.
This interface should be implemented by
QueryNode that holds a field and an arbitrary
value.Configuration parameters for
FuzzyQuerysBuilder for
FuzzyLikeThisQueryA
FuzzyQueryNode represents a element that contains field/text/similarity tupleBuilds a
FuzzyQuery object from a FuzzyQueryNode object.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.An interval function equivalent to
FuzzyQuery.A
GroupQueryNode represents a location where the original user typed real parenthesis on
the query string.Builds no object, it only returns the
Query object set on the GroupQueryNode
object using a QueryTreeBuilder.QUERY_TREE_BUILDER_TAGID tag.Representation of an interval function that can be converted to
IntervalsSource.Node that represents an interval function.
Builds a
Query from an IntervalQueryNode.This processor makes sure that
StandardQueryConfigHandler.ConfigurationKeys.ANALYZER is defined in the QueryConfigHandler and injects this analyzer into IntervalQueryNodes.Builder for
MoreLikeThisQueryBuilder for
MatchAllDocsQueryA
MatchAllDocsQueryNode indicates that a query node tree or subtree will match all
documents if executed in the index.Builds a
MatchAllDocsQuery object from a MatchAllDocsQueryNode object.This processor converts every
WildcardQueryNode that is "*:*" to MatchAllDocsQueryNode.A
MatchNoDocsQueryNode indicates that a query node tree or subtree will not match any
documents if executed in the index.Builds a
MatchNoDocsQuery object from a MatchNoDocsQueryNode object.Node that represents
Intervals.maxgaps(int, IntervalsSource).Node that represents
Intervals.maxwidth(int, IntervalsSource).Message Interface for a lazy loading.
Default implementation of Message interface.
Node that represents a minimum-should-match restriction on a
GroupQueryNode.Builds a
BooleanQuery from a MinShouldMatchNode.A
ModifierQueryNode indicates the modifier value (+,-,?,NONE) for each term on the query
string.Modifier type: such as required (REQ), prohibited (NOT)
Builds no object, it only returns the
Query object set on the ModifierQueryNode
object using a QueryTreeBuilder.QUERY_TREE_BUILDER_TAGID tag.This processor is used to expand terms so the query looks for the same term in different fields.
A QueryParser which constructs queries to search multiple fields.
A
MultiPhraseQueryNode indicates that its children should be used to build a MultiPhraseQuery instead of PhraseQuery.Builds a
MultiPhraseQuery object from a MultiPhraseQueryNode object.This processor instates the default
MultiTermQuery.RewriteMethod, MultiTermQuery.CONSTANT_SCORE_BLENDED_REWRITE, for multi-term query nodes.MessageBundles classes extend this class, to implement a bundle.
Interface that exceptions should implement to support lazy loading of messages.
A
NoChildOptimizationQueryNodeProcessor removes every BooleanQueryNode, BoostQueryNode,
TokenizedPhraseQueryNode or ModifierQueryNode that do not have a valid children.Node that represents
Intervals.nonOverlapping(IntervalsSource, IntervalsSource) .Node that represents
Intervals.notContainedBy(IntervalsSource, IntervalsSource).Node that represents
Intervals.notContaining(IntervalsSource, IntervalsSource).A
NoTokenFoundQueryNode is used if a term is convert into no tokens by the
tokenizer/lemmatizer/analyzer (null).Factory for prohibited clauses
Node that represents
Intervals.notWithin(IntervalsSource, int, IntervalsSource).A
OpaqueQueryNode is used for specify values that are not supposed to be parsed by the
parser.Processes
TermRangeQuerys with open ranges.Node that represents
Intervals.or(IntervalsSource...).Node that represents
Intervals.ordered(IntervalsSource...).Factory for disjunctions
A
OrQueryNode represents an OR boolean operation performed on a list of nodes.Node that represents
Intervals.overlapping(IntervalsSource, IntervalsSource).This exception is thrown when parse errors are encountered.
This exception is thrown when parse errors are encountered.
This exception is thrown when parse errors are encountered.
Thrown when the xml queryparser encounters invalid syntax/configuration.
This class represents an extension base class to the Lucene standard
QueryParser.A
PathQueryNode is used to store queries like /company/USA/California
/product/shoes/brown.Term text with a beginning and end position
Node that represents
Intervals.phrase(String...).Builds a
PhraseQuery object from a TokenizedPhraseQueryNode object.Query node for
PhraseQuery's slop factor.This processor removes invalid
SlopQueryNode objects in the query node tree.This query node represents a field query that holds a point value.
This processor is used to convert
FieldQueryNodes to PointRangeQueryNodes.Creates a range query across 1D
PointValues.This query node represents a range query composed by
PointQueryNode bounds, which means
the bound values are Numbers.Builds
PointValues range queries out of PointRangeQueryNodes.This processor is used to convert
TermRangeQueryNodes to PointRangeQueryNodes.This class holds the configuration used to parse numeric queries and create
PointValues
queries.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.This processor pipeline extends
StandardQueryNodeProcessorPipeline and enables boolean
precedence on it.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>.A
PrefixWildcardQueryNode represents wildcardquery that matches abc* or *.Builds a
PrefixQuery object from a PrefixWildcardQueryNode object.A
ProximityQueryNode represents a query where the terms should meet specific distance
conditions.utility class containing the distance condition and number
Distance condition: PARAGRAPH, SENTENCE, or NUMBER
This interface is used by implementors classes that builds some kind of object from a query tree.
Implemented by objects that produce Lucene Query objects from XML streams.
Factory for
QueryBuilderThis class can be used to hold any query configuration and no field configuration.
A
QueryNode is a interface implemented by all nodes on a QueryNode tree.Error class with NLS support
This exception should be thrown if something wrong happens when dealing with
QueryNodes.A
QueryNodeImpl is the default implementation of the interface QueryNodeAllow joining 2 QueryNode Trees, into one.
This should be thrown when an exception happens during the query parsing from string to the query
node tree.
A
QueryNodeProcessor is an interface for classes that process a QueryNode tree.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.A
QueryNodeProcessorPipeline class should be used to build a query node processor
pipeline.This class is generated by JavaCC.
This class is generated by JavaCC.
The default operator for parsing queries.
This class is overridden by QueryParser in QueryParser.jj and acts to separate the majority of
the Java code from the .jj grammar file.
Token literal values and constants.
Token literal values and constants.
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.
Flexible Query Parser message bundle class
Token Manager.
Token Manager.
This class defines utility methods to (help) parse query strings into
Query objects.This class should be used when there is a builder for each type of node.
A
QuotedFieldQueryNode represents phrase query.Builder for
TermRangeQueryThis interface should be implemented by a
QueryNode that represents some kind of range
query.A
RegexpQueryNode represents RegexpQuery query Examples: /[a-z]|[0-9]/Builds a
RegexpQuery object from a RegexpQueryNode object.Processor for Regexp queries.
A
QueryNodeProcessorPipeline class removes every instance of DeletedQueryNode
from a query node tree.This processor removes every
QueryNode that is not a leaf and has not children.SimpleQueryParser is used to parse human readable query syntax.
Base class for queries that expand to sets of simple terms.
Callback to visit each matching term during "rewrite" in
SimpleTerm.MatchingTermVisitor.visitMatchingTerm(Term)A
SlopQueryNode represents phrase query with a slop.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.Base class for building
SpanQuerysBuilder for
SpanFirstQueryBuilder for
SpanNearQueryFactory for
SpanOrQueryBuilder for
SpanNotQueryBuilder for
SpanOrQueryBuilder that analyzes the text into a
SpanOrQueryBuilder for
SpanPositionRangeQueryInterface for retrieving a
SpanQuery.Factory for
SpanQueryBuildersBuilder for
SpanTermQueryQuery that matches String prefixes
Lowest level base class for surround queries
Simple single-term clause
Query that matches wildcards
This query configuration handler is used for almost every processor defined in the
StandardQueryNodeProcessorPipeline processor pipeline.Class holding keys for StandardQueryNodeProcessorPipeline options.
Boolean Operator: AND or OR
This pipeline has all the processors needed to process a query node tree, generated by
StandardSyntaxParser, already assembled.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.This query tree builder only defines the necessary map to build a
Query tree object.Parser for the standard Lucene syntax
Token literal values and constants.
Token Manager.
String manipulation routines
QueryNode for clauses that are synonym of each other.Builder for
SynonymQueryNode.A parser needs to implement
SyntaxParser interfaceBuilder for
TermQueryThis query node represents a range query composed by
FieldQueryNode bounds, which means
the bound values are strings.Builds a
TermRangeQuery object from a TermRangeQueryNode object.This processors process
TermRangeQueryNodes.Builds a BooleanQuery from all of the terms found in the XML element using the choice of analyzer
Interface for a node that has text as a
CharSequenceDescribes the input token stream.
Describes the input token stream.
Describes the input token stream.
A
TokenizedPhraseQueryNode represents a node created by a code that
tokenizes/lemmatizes/analyzes.Token Manager Error.
Token Manager Error.
Token Manager Error.
Exception thrown when
BasicQueryFactory would exceed the limit of query clauses.CharsSequence with escaped chars information.
Node that represents
Intervals.unordered(IntervalsSource...).Node that represents
Intervals.unorderedNoOverlaps(IntervalsSource, IntervalsSource).UserInputQueryBuilder uses 1 of 2 strategies for thread-safe parsing: 1) Synchronizing access to
"parse" calls on a previously supplied QueryParser or..
This interface should be implemented by
QueryNode that holds an arbitrary value.Node that represents
Intervals.wildcard(BytesRef).A
WildcardQueryNode represents wildcard query This does not apply to phrases.Builds a
WildcardQuery object from a WildcardQueryNode object.The
StandardSyntaxParser creates PrefixWildcardQueryNode nodes which have values
containing the prefixed wildcard.Node that represents
Intervals.within(IntervalsSource, int, IntervalsSource).