|
|||||||||
PREV NEXT | FRAMES NO FRAMES |
Packages that use Query | |
---|---|
org.apache.lucene.index | Code to maintain and access indices. |
org.apache.lucene.search | Code to search indices. |
org.apache.lucene.search.payloads | The payloads package provides Query mechanisms for finding and using payloads. |
org.apache.lucene.search.spans | The calculus of spans. |
Uses of Query in org.apache.lucene.index |
---|
Methods in org.apache.lucene.index with parameters of type Query | |
---|---|
void |
IndexWriter.deleteDocuments(Query... queries)
Deletes the document(s) matching any of the provided queries. |
long |
TrackingIndexWriter.deleteDocuments(Query... queries)
Calls IndexWriter.deleteDocuments(Query...)
and returns the generation that reflects this change. |
void |
IndexWriter.deleteDocuments(Query query)
Deletes the document(s) matching the provided query. |
long |
TrackingIndexWriter.deleteDocuments(Query q)
Calls IndexWriter.deleteDocuments(Query) and
returns the generation that reflects this change. |
Uses of Query in org.apache.lucene.search |
---|
Classes in org.apache.lucene.search with type parameters of type Query | |
---|---|
class |
ScoringRewrite<Q extends Query>
Base rewrite method that translates each term into a query, and keeps the scores as computed by the query. |
class |
TopTermsRewrite<Q extends Query>
Base rewrite method for collecting only the top terms via a priority queue. |
Subclasses of Query in org.apache.lucene.search | |
---|---|
class |
AutomatonQuery
A Query that will match terms against a finite-state machine. |
class |
BooleanQuery
A Query that matches documents matching boolean combinations of other queries, e.g. |
class |
ConstantScoreQuery
A query that wraps another query or a filter and simply returns a constant score equal to the query boost for every document that matches the filter or query. |
class |
DisjunctionMaxQuery
A query that generates the union of documents produced by its subqueries, and that scores each document with the maximum score for that document as produced by any subquery, plus a tie breaking increment for any additional matching subqueries. |
class |
FilteredQuery
A query that applies a filter to the results of another query. |
class |
FuzzyQuery
Implements the fuzzy search query. |
class |
MatchAllDocsQuery
A query that matches all documents. |
class |
MultiPhraseQuery
MultiPhraseQuery is a generalized version of PhraseQuery, with an added method MultiPhraseQuery.add(Term[]) . |
class |
MultiTermQuery
An abstract Query that matches documents
containing a subset of terms provided by a FilteredTermsEnum enumeration. |
class |
NGramPhraseQuery
This is a PhraseQuery which is optimized for n-gram phrase query. |
class |
NumericRangeQuery<T extends Number>
A Query that matches numeric values within a
specified range. |
class |
PhraseQuery
A Query that matches documents containing a particular sequence of terms. |
class |
PrefixQuery
A Query that matches documents containing terms with a specified prefix. |
class |
RegexpQuery
A fast regular expression query based on the org.apache.lucene.util.automaton package. |
class |
TermQuery
A Query that matches documents containing a term. |
class |
TermRangeQuery
A Query that matches documents within an range of terms. |
class |
WildcardQuery
Implements the wildcard search query. |
Fields in org.apache.lucene.search declared as Query | |
---|---|
protected Query |
ConstantScoreQuery.query
|
Methods in org.apache.lucene.search that return Query | |
---|---|
Query |
Query.clone()
Returns a clone of this query. |
Query |
BooleanQuery.BooleanWeight.getQuery()
|
Query |
DisjunctionMaxQuery.DisjunctionMaxWeight.getQuery()
Return our associated DisjunctionMaxQuery |
Query |
QueryWrapperFilter.getQuery()
returns the inner Query |
Query |
FilteredQuery.getQuery()
Returns this FilteredQuery's (unfiltered) Query |
Query |
BooleanClause.getQuery()
|
abstract Query |
Weight.getQuery()
The query that this concerns. |
Query |
ConstantScoreQuery.getQuery()
Returns the encapsulated query, returns null if a filter is wrapped. |
Query |
ConstantScoreQuery.ConstantWeight.getQuery()
|
Query |
BooleanQuery.rewrite(IndexReader reader)
|
Query |
PhraseQuery.rewrite(IndexReader reader)
|
Query |
DisjunctionMaxQuery.rewrite(IndexReader reader)
Optimize our representation and our subqueries representations |
Query |
MultiPhraseQuery.rewrite(IndexReader reader)
|
Query |
MultiTermQuery.rewrite(IndexReader reader)
To rewrite to a simpler form, instead return a simpler enum from MultiTermQuery.getTermsEnum(Terms, AttributeSource) . |
Query |
NGramPhraseQuery.rewrite(IndexReader reader)
|
Query |
FilteredQuery.rewrite(IndexReader reader)
Rewrites the query. |
Query |
Query.rewrite(IndexReader reader)
Expert: called to re-write queries into primitive queries. |
Query |
ConstantScoreQuery.rewrite(IndexReader reader)
|
Query |
FieldCacheRewriteMethod.rewrite(IndexReader reader,
MultiTermQuery query)
|
Query |
DocTermOrdsRewriteMethod.rewrite(IndexReader reader,
MultiTermQuery query)
|
abstract Query |
MultiTermQuery.RewriteMethod.rewrite(IndexReader reader,
MultiTermQuery query)
|
Query |
IndexSearcher.rewrite(Query original)
Expert: called to re-write queries into primitive queries. |
protected Query |
IndexSearcher.wrapFilter(Query query,
Filter filter)
|
Methods in org.apache.lucene.search that return types with arguments of type Query | |
---|---|
ArrayList<Query> |
DisjunctionMaxQuery.getDisjuncts()
|
Iterator<Query> |
DisjunctionMaxQuery.iterator()
|
Methods in org.apache.lucene.search with parameters of type Query | |
---|---|
void |
DisjunctionMaxQuery.add(Query query)
Add a subquery to this disjunction |
void |
BooleanQuery.add(Query query,
BooleanClause.Occur occur)
Adds a clause to a boolean query. |
Weight |
IndexSearcher.createNormalizedWeight(Query query)
Creates a normalized weight for a top-level Query . |
Explanation |
IndexSearcher.explain(Query query,
int doc)
Returns an Explanation that describes how doc scored against
query . |
Query |
IndexSearcher.rewrite(Query original)
Expert: called to re-write queries into primitive queries. |
void |
IndexSearcher.search(Query query,
Collector results)
Lower-level search API. |
void |
IndexSearcher.search(Query query,
Filter filter,
Collector results)
Lower-level search API. |
TopDocs |
IndexSearcher.search(Query query,
Filter filter,
int n)
Finds the top n
hits for query , applying filter if non-null. |
TopFieldDocs |
IndexSearcher.search(Query query,
Filter filter,
int n,
Sort sort)
Search implementation with arbitrary sorting. |
TopFieldDocs |
IndexSearcher.search(Query query,
Filter filter,
int n,
Sort sort,
boolean doDocScores,
boolean doMaxScore)
Search implementation with arbitrary sorting, plus control over whether hit scores and max score should be computed. |
TopDocs |
IndexSearcher.search(Query query,
int n)
Finds the top n
hits for query . |
TopFieldDocs |
IndexSearcher.search(Query query,
int n,
Sort sort)
Search implementation with arbitrary sorting and no filter. |
TopDocs |
IndexSearcher.searchAfter(ScoreDoc after,
Query query,
Filter filter,
int n)
Finds the top n
hits for query , applying filter if non-null,
where all results are after a previous result (after ). |
TopDocs |
IndexSearcher.searchAfter(ScoreDoc after,
Query query,
Filter filter,
int n,
Sort sort)
Finds the top n
hits for query , applying filter if non-null,
where all results are after a previous result (after ). |
TopDocs |
IndexSearcher.searchAfter(ScoreDoc after,
Query query,
Filter filter,
int n,
Sort sort,
boolean doDocScores,
boolean doMaxScore)
Finds the top n
hits for query where all results are after a previous
result (after ), allowing control over
whether hit scores and max score should be computed. |
TopDocs |
IndexSearcher.searchAfter(ScoreDoc after,
Query query,
int n)
Finds the top n
hits for query where all results are after a previous
result (after ). |
TopDocs |
IndexSearcher.searchAfter(ScoreDoc after,
Query query,
int n,
Sort sort)
Finds the top n
hits for query where all results are after a previous
result (after ). |
void |
BooleanClause.setQuery(Query query)
|
protected Query |
IndexSearcher.wrapFilter(Query query,
Filter filter)
|
Method parameters in org.apache.lucene.search with type arguments of type Query | |
---|---|
void |
DisjunctionMaxQuery.add(Collection<Query> disjuncts)
Add a collection of disjuncts to this disjunction via Iterable<Query> |
Constructors in org.apache.lucene.search with parameters of type Query | |
---|---|
BooleanClause(Query query,
BooleanClause.Occur occur)
Constructs a BooleanClause. |
|
ConstantScoreQuery(Query query)
Strips off scores from the passed in Query. |
|
FilteredQuery(Query query,
Filter filter)
Constructs a new query which applies a filter to the results of the original query. |
|
FilteredQuery(Query query,
Filter filter,
FilteredQuery.FilterStrategy strategy)
Expert: Constructs a new query which applies a filter to the results of the original query. |
|
QueryWrapperFilter(Query query)
Constructs a filter which only matches documents matching query . |
Constructor parameters in org.apache.lucene.search with type arguments of type Query | |
---|---|
DisjunctionMaxQuery(Collection<Query> disjuncts,
float tieBreakerMultiplier)
Creates a new DisjunctionMaxQuery |
Uses of Query in org.apache.lucene.search.payloads |
---|
Subclasses of Query in org.apache.lucene.search.payloads | |
---|---|
class |
PayloadNearQuery
This class is very similar to SpanNearQuery except that it factors
in the value of the payloads located at each of the positions where the
TermSpans occurs. |
class |
PayloadTermQuery
This class is very similar to SpanTermQuery except that it factors
in the value of the payload located at each of the positions where the
Term occurs. |
Methods in org.apache.lucene.search.payloads with parameters of type Query | |
---|---|
Collection<byte[]> |
PayloadSpanUtil.getPayloadsForQuery(Query query)
Query should be rewritten for wild/fuzzy support. |
Uses of Query in org.apache.lucene.search.spans |
---|
Subclasses of Query in org.apache.lucene.search.spans | |
---|---|
class |
FieldMaskingSpanQuery
Wrapper to allow SpanQuery objects participate in composite
single-field SpanQueries by 'lying' about their search field. |
class |
SpanFirstQuery
Matches spans near the beginning of a field. |
class |
SpanMultiTermQueryWrapper<Q extends MultiTermQuery>
Wraps any MultiTermQuery as a SpanQuery ,
so it can be nested within other SpanQuery classes. |
class |
SpanNearPayloadCheckQuery
Only return those matches that have a specific payload at the given position. |
class |
SpanNearQuery
Matches spans which are near one another. |
class |
SpanNotQuery
Removes matches which overlap with another SpanQuery or within a x tokens before or y tokens after another SpanQuery. |
class |
SpanOrQuery
Matches the union of its clauses. |
class |
SpanPayloadCheckQuery
Only return those matches that have a specific payload at the given position. |
class |
SpanPositionCheckQuery
Base class for filtering a SpanQuery based on the position of a match. |
class |
SpanPositionRangeQuery
Checks to see if the SpanPositionCheckQuery.getMatch() lies between a start and end position |
class |
SpanQuery
Base class for span-based queries. |
class |
SpanTermQuery
Matches spans containing a term. |
Methods in org.apache.lucene.search.spans that return Query | |
---|---|
Query |
SpanWeight.getQuery()
|
Query |
FieldMaskingSpanQuery.rewrite(IndexReader reader)
|
Query |
SpanMultiTermQueryWrapper.rewrite(IndexReader reader)
|
Query |
SpanOrQuery.rewrite(IndexReader reader)
|
Query |
SpanNearQuery.rewrite(IndexReader reader)
|
Query |
SpanNotQuery.rewrite(IndexReader reader)
|
Query |
SpanPositionCheckQuery.rewrite(IndexReader reader)
|
|
|||||||||
PREV NEXT | FRAMES NO FRAMES |