Name | Description |
---|---|
AssertingQuery | Assertion-enabled query. |
AutomatonQuery | A Query that will match terms against a finite-state machine. this query will match documents that contain terms accepted by a given finite-state machine. The automaton can be constructed with the Lucene.Net.Util.Automaton API. Alternatively, it can be created from a regular expression with RegexpQuery or from the standard Lucene wildcard syntax with WildcardQuery. When the query is executed, it will create an equivalent DFA of the finite-state machine, and will enumerate the term dictionary in an intelligent way to reduce the number of comparisons. For example: the regular expression of |
BaseTestRangeFilter | |
BaseTestRangeFilter.TestIndex | Collation interacts badly with hyphens -- collation produces different ordering than Unicode code-point ordering -- so two indexes are created: one which can't have negative random integers, for testing collated ranges, and the other which can have negative random integers, for all other tests. |
BinaryCoordSimilarity | Custom similarity to boost relevance of documents containing all query terms (as opposed to only some of them) |
BitsFilteredDocIdSet | this implementation supplies a filtered DocIdSet, that excludes all docids which are not in a Bits instance. this is especially useful in Lucene.Net.Search.Filter to apply the {@code acceptDocs} passed to {@code getDocIdSet()} before returning the final DocIdSet. |
BooleanClause | |
BooleanFilter | |
BooleanFilterTest | |
BoostingQuery | The BoostingQuery class can be used to effectively demote results that match a given query. Unlike the "NOT" clause, this still selects documents that contain undesirable terms, but reduces their overall score: Query balancedQuery = new BoostingQuery(positiveQuery, negativeQuery, 0.01f);In this scenario the positiveQuery contains the mandatory, desirable criteria which is used to select all matching documents, and the negativeQuery contains the undesirable elements which are simply used to lessen the scores. Documents that match the negativeQuery have their score multiplied by the supplied "boost" parameter, so this should be less than 1 to achieve a demoting effect This code was originally made available here: mailing list and is documented here: Documentation |
BoostingQuery.AnonymousBooleanQuery | |
BoostingQuery.AnonymousDefaultSimilarity | |
CachingCollector | Caches all docs, and optionally also scores, coming from a search, and is then able to replay them to another collector. You specify the max RAM this class may use. Once the collection is done, call #isCached. If this returns true, you can use #replay(Collector) against a new collector. If it returns false, this means too much RAM was required and you must instead re-run the original search. NOTE: this class consumes 4 (or 8 bytes, if scoring is cached) per collected document. If the result set is large this can easily be a very substantial amount of RAM! NOTE: this class caches at least 128 documents before checking RAM limits. See the Lucene modules/grouping module for more details including a full code example. @lucene.experimental |
CachingCollector.CachedScorer | |
CachingCollector.CollectorAnonymousInnerClassHelper | |
CachingCollector.NoScoreCachingCollector | |
CachingCollector.ScoreCachingCollector | |
CachingCollector.SegStart | |
CheckHits | |
CheckHits.ExplanationAsserter | Asserts that the score explanation for every document matching a query corresponds with the true score. NOTE: this HitCollector should only be used with the Query and Searcher specified at when it is constructed. |
CheckHits.ExplanationAssertingSearcher | an IndexSearcher that implicitly checks hte explanation of every match whenever it executes a search. |
CheckHits.SetCollector | Just collects document ids into a set. |
Collector | Expert: Collectors are primarily meant to be used to gather raw results from a search, and implement sorting or custom result filtering, collation, etc.
Lucene's core collectors are derived from Collector. Likely your application can use one of these classes, or subclass TopDocsCollector, instead of implementing Collector directly: Collector decouples the score from the collected doc: the score computation is skipped entirely if it's not needed. Collectors that do need the score should implement the SetScorer method, to hold onto the passed Scorer instance, and call Scorer.Score() within the collect method to compute the current hit's score. If your collector may request the score for a single hit multiple times, you should use ScoreCachingWrappingScorer.
NOTE: The doc that is passed to the collect method is relative to the current reader. If your collector needs to resolve this to the docID space of the Multi*Reader, you must re-base it by recording the docBase from the most recent setNextReader call. Here's a simple example showing how to collect docIDs into a BitSet: Not all collectors will need to rebase the docID. For example, a collector that simply counts the total number of hits would skip it.
NOTE: Prior to 2.9, Lucene silently filtered out hits with score <= 0. As of 2.9, the core Collectors no longer do that. It's very unusual to have such hits (a negative query boost, or function query returning negative custom scores, could cause it to happen). If you need that behavior, use PositiveScoresOnlyCollector .
NOTE: This API is experimental and might change in incompatible ways in the next release. |
ConstantScoreQuery | |
ConstantScoreQuery.ConstantScorer | |
ConstantScoreQuery.ConstantWeight | |
DefaultSimilarity | |
DisjunctionMaxScorer | The Scorer for DisjunctionMaxQuery's. The union of all documents generated by the the subquery scorers is generated in document number order. The score for each document is the maximum of the scores computed by the subquery scorers that generate that document, plus tieBreakerMultiplier times the sum of the scores for the other subqueries that generate the document. |
DisjunctionSumScorer | A Scorer for OR like queries, counterpart of ConjunctionScorer . This Scorer implements DocIdSetIterator.SkipTo(int) and uses skipTo() on the given Scorers. |
DocIdSetIterator | this abstract class defines methods to iterate over a set of non-decreasing doc ids. Note that this class assumes it iterates on doc Ids, and therefore #NO_MORE_DOCS is set to {@value #NO_MORE_DOCS} in order to be used as a sentinel object. Implementations of this class are expected to consider Integer#MAX_VALUE as an invalid value. |
DocIdSetIterator.DocIdSetIteratorAnonymousInnerClassHelper | |
DuplicateFilter | |
DuplicateFilterTest | |
ElevationComparatorSource | |
ElevationComparatorSource.AnonymousClassFieldComparator | |
ElevationComparatorSource.FieldComparatorAnonymousInnerClassHelper | |
Explanation | |
Explanation.IDFExplanation | |
FacetCount | Simplified version of FacetHits containing the count only. This means that IndexReader does not need to be held open. Useful for the majority of casses where we're only interested in the count and not the individual Documents. |
FieldCacheImpl | Expert: The default cache implementation, storing all values in memory. A WeakHashMap is used for storage. Created: May 19, 2004 4:40:36 PM |
FieldCacheImpl.ByteCache | |
FieldCacheImpl.Cache | Expert: Internal cache. |
FieldCacheImpl.CacheEntryImpl | |
FieldCacheImpl.DoubleCache | |
FieldCacheImpl.Entry | Expert: Every composite-key in the internal cache is of this type. |
FieldCacheImpl.FloatCache | |
FieldCacheImpl.IntCache | |
FieldCacheImpl.LongCache | |
FieldCacheImpl.ShortCache | |
FieldCacheImpl.StringCache | |
FieldCacheImpl.StringIndexCache | |
FieldComparator | Expert: a FieldComparator compares hits so as to determine their sort order when collecting the top results with TopFieldCollector . The concrete public FieldComparator classes here correspond to the SortField types. This API is designed to achieve high performance sorting, by exposing a tight interaction with FieldValueHitQueue as it visits hits. Whenever a hit is competitive, it's enrolled into a virtual slot, which is an int ranging from 0 to numHits-1. The FieldComparator is made aware of segment transitions during searching in case any internal state it's tracking needs to be recomputed during these transitions.
A comparator must define these functions: |
FieldComparator.ByteComparator | Parses field's values as byte (using FieldCache.GetBytes(Lucene.Net.Index.IndexReader,string) and sorts by ascending value |
FieldComparator.DocComparator | Sorts by ascending docID |
FieldComparator.DoubleComparator | Parses field's values as double (using FieldCache.GetDoubles(Lucene.Net.Index.IndexReader,string) and sorts by ascending value |
FieldComparator.FloatComparator | Parses field's values as float (using FieldCache.GetFloats(Lucene.Net.Index.IndexReader,string) and sorts by ascending value |
FieldComparator.IntComparator | Parses field's values as int (using FieldCache.GetInts(Lucene.Net.Index.IndexReader,string) and sorts by ascending value |
FieldComparator.LongComparator | Parses field's values as long (using FieldCache.GetLongs(Lucene.Net.Index.IndexReader,string) and sorts by ascending value |
FieldComparator.RelevanceComparator | Sorts by descending relevance. NOTE: if you are sorting only by descending relevance and then secondarily by ascending docID, peformance is faster using TopScoreDocCollector directly (which Searcher.Search(Query) uses when no Sort is specified). |
FieldComparator.ShortComparator | Parses field's values as short (using FieldCache.GetShorts(IndexReader, string)) and sorts by ascending value |
FieldComparator.StringComparatorLocale | Sorts by a field's value using the Collator for a given Locale. |
FieldComparator.StringOrdValComparator | Sorts by field's natural String sort order, using ordinals. This is functionally equivalent to FieldComparator.StringValComparator , but it first resolves the string to their relative ordinal positions (using the index returned by FieldCache.GetStringIndex), and does most comparisons using the ordinals. For medium to large results, this comparator will be much faster than FieldComparator.StringValComparator. For very small result sets it may be slower. |
FieldComparator.StringValComparator | Sorts by field's natural String sort order. All comparisons are done using String.compareTo, which is slow for medium to large result sets but possibly very fast for very small results sets. |
FieldDoc | Expert: A ScoreDoc which also contains information about how to sort the referenced document. In addition to the document number and score, this object contains an array of values for the document from the field(s) used to sort. For example, if the sort criteria was to sort by fields "a", "b" then "c", the fields object array will have three elements, corresponding respectively to the term values for the document in fields "a", "b" and "c". The class of each element in the array will be either Integer, Float or String depending on the type of values in the terms of each field. Created: Feb 11, 2004 1:23:38 PM @since lucene 1.4 |
FieldValuesBitSets | |
FieldValuesDocIDs | "internal" class to extract the DocIDs of each value of a field |
Filter | |
FilterClause | |
FilteredDocIdSet | Abstract decorator class for a DocIdSet implementation that provides on-demand filtering/validation mechanism on a given DocIdSet. Technically, this same functionality could be achieved with ChainedFilter (under queries/), however the benefit of this class is it never materializes the full bitset for the filter. Instead, the #match method is invoked on-demand, per docID visited during searching. If you know few docIDs will be visited, and the logic behind #match is relatively costly, this may be a better way to filter than ChainedFilter. |
FilteredDocIdSet.BitsAnonymousInnerClassHelper | |
FilteredDocIdSet.FilteredDocIdSetIteratorAnonymousInnerClassHelper | |
FuzzyQuery | Implements the fuzzy search query. The similarity measurement is based on the Damerau-Levenshtein (optimal string alignment) algorithm, though you can explicitly choose classic Levenshtein by passing false to the transpositions parameter. this query uses MultiTermQuery.TopTermsScoringBooleanQueryRewrite as default. So terms will be collected and scored according to their edit distance. Only the top terms are used for building the BooleanQuery. It is not recommended to change the rewrite mode for fuzzy queries. At most, this query will match terms up to {@value Lucene.Net.Util.Automaton.LevenshteinAutomata#MAXIMUM_SUPPORTED_DISTANCE} edits. Higher distances (especially with transpositions enabled), are generally not useful and will match a significant amount of the term dictionary. If you really want this, consider using an n-gram indexing technique (such as the SpellChecker in the suggest module) instead. NOTE: terms of length 1 or 2 will sometimes not match because of how the scaled distance between two terms is computed. For a term to match, the edit distance between the terms must be less than the minimum length term (either the input term, or the candidate term). For example, FuzzyQuery on term "abcd" with maxEdits=2 will not match an indexed term "ab", and FuzzyQuery on term "a" with maxEdits=2 will not match an indexed term "abc". |
FuzzyTermsEnum | Subclass of TermsEnum for enumerating all terms that are similar to the specified filter term. Term enumerations are always ordered by #getComparator. Each term in the enumeration is greater than all that precede it. |
FuzzyTermsEnum.AutomatonFuzzyTermsEnum | Implement fuzzy enumeration with Terms.intersect. this is the fastest method as opposed to LinearFuzzyTermsEnum: as enumeration is logarithmic to the number of terms (instead of linear) and comparison is linear to length of the term (rather than quadratic) |
FuzzyTermsEnum.LevenshteinAutomataAttribute | Stores compiled automata as a list (indexed by edit distance) @lucene.internal |
IndexSearcher | Implements search over a single IndexReader. Applications usually need only call the inherited {@link #Search(Query)} or {@link #Search(Query,Filter)} methods. For performance reasons it is recommended to open only one IndexSearcher and use it for all of your searches. Note that you can only access Hits from an IndexSearcher as long as it is not yet closed, otherwise an IOException will be thrown. |
MockFilter | |
MultiPhraseQuery | |
MultiPhraseQuery.MultiPhraseWeight | |
MultiSearcher | Implements search over a set of Searchables . Applications usually need only call the inherited Searcher.Search(Query, int) or Searcher.Search(Query,Filter, int) methods. |
MultiSearcher.AnonymousClassCollector | |
MultiSearcher.CachedDfSource | Document Frequency cache acting as a Dummy-Searcher. This class is no full-fledged Searcher, but only supports the methods necessary to initialize Weights. |
MultiTermQuery | |
MultiTermQuery.AnonymousClassConstantScoreAutoRewrite | |
MultiTermQuery.ConstantScoreAutoRewrite | |
MultiTermQuery.ConstantScoreBooleanQueryRewrite | |
MultiTermQuery.ConstantScoreFilterRewrite | |
MultiTermQuery.ScoringBooleanQueryRewrite | |
MultiThreadTermVectorsReader | |
Occur | |
PayloadFilter | |
PhraseQuery | |
PhraseQuery.PhraseWeight | |
PrefixQuery | |
Query | |
QueryUtils | Utility class for sanity-checking queries. |
QueryUtils.AnonymousClassCollector | |
QueryUtils.AnonymousClassCollector1 | |
QueryUtils.AnonymousClassQuery | |
QueryUtils.CollectorAnonymousInnerClassHelper | |
QueryUtils.CollectorAnonymousInnerClassHelper2 | |
QueryUtils.FCInvisibleMultiReader | this is a MultiReader that can be used for randomly wrapping other readers without creating FieldCache insanity. The trick is to use an opaque/fake cache key. |
QueryUtils.QueryAnonymousInnerClassHelper | |
RegexpQuery | A fast regular expression query based on the Lucene.Net.Util.Automaton package.
The supported syntax is documented in the RegExp class. Note this might be different than other regular expression implementations. For some alternatives with different syntax, look under the sandbox. Note this query can be slow, as it needs to iterate over many terms. In order to prevent extremely slow RegexpQueries, a Regexp term should not start with the expression |
RegexpQuery.AutomatonProviderAnonymousInnerClassHelper | |
ReqOptSumScorer | A Scorer for queries with a required part and an optional part. Delays skipTo() on the optional part until a score() is needed. this Scorer implements Scorer#advance(int). |
RewriteMethod | |
SampleComparable | |
SampleComparable.AnonymousClassSortComparator | |
SampleComparable.AnonymousClassSortComparatorSource | |
SampleComparable.AnonymousClassSortComparatorSource.AnonymousClassScoreDocComparator | |
SearchEquivalenceTestBase | Simple base class for checking search equivalence. Extend it, and write tests that create #randomTerm()s (all terms are single characters a-z), and use #assertSameSet(Query, Query) and #assertSubsetOf(Query, Query) |
Searcher | An abstract base class for search implementations. Implements the main search methods. Note that you can only access Hits from a Searcher as long as it is not yet closed, otherwise an IOException will be thrown. |
ShardSearchingTestBase | Base test class for simulating distributed search across multiple shards. |
ShardSearchingTestBase.ChangeIndices | |
ShardSearchingTestBase.FieldAndShardVersion | |
ShardSearchingTestBase.NodeState | |
ShardSearchingTestBase.NodeState.ShardIndexSearcher | Matches docs in the local shard but scores based on aggregated stats ("mock distributed scoring") from all nodes. |
ShardSearchingTestBase.SearcherAndVersion | An IndexSearcher and associated version (lease) |
ShardSearchingTestBase.SearcherExpiredException | Thrown when the lease for a searcher has expired. |
ShardSearchingTestBase.TermAndShardVersion | |
Similarity | |
Similarity.AnonymousClassIDFExplanation1 | |
Similarity.AnonymousClassIDFExplanation3 | |
SimpleFacetedSearch | |
SingleDocTestFilter | |
SingleTermEnum | Subclass of FilteredTermEnum for enumerating a single term. This can be used by MultiTermQuerys that need only visit one term, but want to preserve MultiTermQuery semantics such as RewriteMethod. |
SortField | Stores information about how to sort documents by terms in an individual field. Fields must be indexed in order to sort by them. Created: Feb 11, 2004 1:25:29 PM @since lucene 1.4 |
SortField.ObjectAnonymousInnerClassHelper | |
SortField.ObjectAnonymousInnerClassHelper2 | |
SparseFacetedSearcher | Based on SimpleFacetedSearch. Uses DocID lists instead on bitmaps. Efficient memory usage for high cardinality sparsely populated facets. Suitable for high cardinality, sparsely populated facets. i.e. There are a large number of facet values and each facet value is hit in a small percentage of documents. Especially if there are also a large number of documents. SimpleFacetedSearch holds a bitmap for each value representing whether that value is a hit is each document (approx 122KB per 1M documents per facet value). So this is an O(N*M) problem. The memory requirement can grow very quickly. SparseFacetedSearcher records the DocID (Int32) for each value hit (memory cost = values * hits * 4). SimpleFacetedSearch record a bit for evey document per value (memory cost = values * documents / 8). So if the average number of hits for each value is less than 1/32 or 3.125% then Sparse is more memory efficient. There are also some enumerable methods than mean there is much less pressure on the GC. Plus some bug fixes. |
SparseFacetedSearcher.FacetName | |
TermQuery | A Query that matches documents containing a term. this may be combined with other terms with a BooleanQuery. |
TermQuery.TermWeight | |
TermsFilter | A filter that contains multiple terms. |
TermsFilterTest | |
TestAutomatonQuery | |
TestAutomatonQuery.ThreadAnonymousInnerClassHelper | |
TestAutomatonQueryUnicode | |
TestBoolean2 | |
TestBoolean2.AnonymousClassDefaultSimilarity | |
TestBoolean2.DefaultSimilarityAnonymousInnerClassHelper | |
TestBooleanMinShouldMatch | |
TestBooleanMinShouldMatch.AnonymousClassCallback | |
TestBooleanMinShouldMatch.CallbackAnonymousInnerClassHelper | |
TestBooleanMinShouldMatch.DefaultSimilarityAnonymousInnerClassHelper | |
TestBooleanMinShouldMatch.DefaultSimilarityAnonymousInnerClassHelper2 | |
TestBooleanOr | |
TestBooleanPrefixQuery | |
TestBooleanQuery | |
TestBooleanQuery.IndexSearcherAnonymousInnerClassHelper | |
TestBooleanScorer | |
TestBooleanScorer.AnonymousClassScorer | |
TestBooleanScorer.BulkScorerAnonymousInnerClassHelper | |
TestBooleanScorer.CollectorAnonymousInnerClassHelper | |
TestBooleanScorer.CollectorAnonymousInnerClassHelper2 | |
TestBooleanScorer.CrazyMustUseBulkScorerQuery | Throws UOE if Weight.scorer is called |
TestBooleanScorer.CrazyMustUseBulkScorerQuery.WeightAnonymousInnerClassHelper | |
TestBooleanScorer.CrazyMustUseBulkScorerQuery.WeightAnonymousInnerClassHelper.BulkScorerAnonymousInnerClassHelper | |
TestCachingWrapperFilter | |
TestCachingWrapperFilter.AnonymousFilter | |
TestCachingWrapperFilter.AnonymousFilter2 | |
TestCachingWrapperFilter.AnonymousFilter2.AnonymousDocIdSet | |
TestCachingWrapperFilter.AnonymousFilter3 | |
TestCachingWrapperFilter.FilterAnonymousInnerClassHelper | |
TestCachingWrapperFilter.FilterAnonymousInnerClassHelper2 | |
TestCachingWrapperFilter.FilterAnonymousInnerClassHelper2.DocIdSetAnonymousInnerClassHelper | |
TestCachingWrapperFilter.FilterAnonymousInnerClassHelper3 | |
TestComplexExplanations | |
TestComplexExplanations.AnonymousClassDefaultSimilarity | |
TestConstantScoreQuery | |
TestConstantScoreQuery.CollectorAnonymousInnerClassHelper | |
TestConstantScoreQuery.DefaultSimilarityAnonymousInnerClassHelper | |
TestCustomSearcherSort | |
TestCustomSearcherSort.CustomSearcher | |
TestCustomSearcherSort.RandomGen | |
TestDateFilter | |
TestDateSort | |
TestDisjunctionMaxQuery | |
TestDisjunctionMaxQuery.TestSimilarity | Similarity to eliminate tf, idf and lengthNorm effects to isolate test case. same as TestRankingSimilarity in TestRanking.zip from http://issues.apache.org/jira/browse/LUCENE-323 |
TestDocBoost | |
TestDocBoost.AnonymousClassCollector | |
TestDocBoost.AnonymousClassHitCollector | |
TestDocIdSet | |
TestDocIdSet.AnonymousClassDocIdSet_Renamed_Class | |
TestDocIdSet.AnonymousClassDocIdSet_Renamed_Class.AnonymousClassDocIdSetIterator | |
TestDocIdSet.AnonymousClassFilter | |
TestDocIdSet.AnonymousClassFilteredDocIdSet | |
TestDocIdSet.DocIdSetAnonymousInnerClassHelper | |
TestDocIdSet.DocIdSetAnonymousInnerClassHelper.DocIdSetIteratorAnonymousInnerClassHelper | |
TestDocIdSet.FilterAnonymousInnerClassHelper | |
TestDocIdSet.FilterAnonymousInnerClassHelper2 | |
TestDocIdSet.FilterAnonymousInnerClassHelper2.DocIdSetAnonymousInnerClassHelper2 | |
TestDocIdSet.FilterAnonymousInnerClassHelper2.FilteredDocIdSetAnonymousInnerClassHelper2 | |
TestDocIdSet.FilteredDocIdSetAnonymousInnerClassHelper | |
TestDocValuesScoring | |
TestDocValuesScoring.BoostingSimilarity | Similarity that wraps another similarity and boosts the final score according to whats in a docvalues field. @lucene.experimental |
TestDocValuesScoring.BoostingSimilarity.SimScorerAnonymousInnerClassHelper | |
TestDocValuesScoring.PerFieldSimilarityWrapperAnonymousInnerClassHelper | |
TestEarlyTermination | |
TestEarlyTermination.CollectorAnonymousInnerClassHelper | |
TestElevationComparator | |
TestExplanations | |
TestExplanations.ItemizedFilter | |
TestFieldCache | |
TestFieldCacheRangeFilter | |
TestFieldCacheTermsFilter | |
TestFilteredQuery | |
TestFilteredQuery.AnonymousClassFilter | |
TestFilteredQuery.AnonymousClassFilter1 | |
TestFilteredQuery.FilterAnonymousInnerClassHelper | |
TestFilteredQuery.FilterAnonymousInnerClassHelper2 | |
TestFilteredQuery.FilterAnonymousInnerClassHelper3 | |
TestFilteredQuery.FilterAnonymousInnerClassHelper3.DocIdSetAnonymousInnerClassHelper | |
TestFilteredQuery.FilterAnonymousInnerClassHelper3.DocIdSetAnonymousInnerClassHelper.BitsAnonymousInnerClassHelper | |
TestFilteredQuery.FilterAnonymousInnerClassHelper4 | |
TestFilteredQuery.FilterAnonymousInnerClassHelper4.DocIdSetAnonymousInnerClassHelper2 | |
TestFilteredQuery.FilterAnonymousInnerClassHelper4.DocIdSetAnonymousInnerClassHelper2.DocIdSetIteratorAnonymousInnerClassHelper | |
TestFilteredQuery.RandomAccessFilterStrategyAnonymousInnerClassHelper | |
TestFilteredSearch | |
TestFilteredSearch.SimpleDocIdSetFilter | |
TestFuzzyQuery | |
TestIndexSearcher | |
TestMatchAllDocsQuery | |
TestMinShouldMatch2 | |
TestMinShouldMatch2.DefaultSimilarityAnonymousInnerClassHelper | |
TestMinShouldMatch2.SlowMinShouldMatchScorer | |
TestMultiPhraseQuery | |
TestMultiPhraseQuery.DefaultSimilarityAnonymousInnerClassHelper | |
TestMultiSearcher | |
TestMultiSearcher.AnonymousClassDefaultSimilarity | |
TestMultiSearcherRanking | |
TestMultiTermConstantScore | |
TestMultiTermConstantScore.AnonymousClassCollector | |
TestMultiTermConstantScore.CollectorAnonymousInnerClassHelper | |
TestMultiTermQueryRewrites | |
TestMultiTermQueryRewrites.MultiTermQueryAnonymousInnerClassHelper | |
TestMultiTermQueryRewrites.MultiTermQueryAnonymousInnerClassHelper.TermRangeTermsEnumAnonymousInnerClassHelper | |
TestMultiThreadTermVectors | |
TestMultiValuedNumericRangeQuery | |
TestNGramPhraseQuery | |
TestNot | |
TestNumericRangeQuery32 | |
TestNumericRangeQuery64 | |
TestParallelMultiSearcher | |
TestPayloadAnalyzer | |
TestPhrasePrefixQuery | |
TestPhraseQuery | |
TestPhraseQuery.AnonymousClassAnalyzer | |
TestPositionIncrement | |
TestPositionIncrement.AnalyzerAnonymousInnerClassHelper | |
TestPositionIncrement.AnalyzerAnonymousInnerClassHelper.TokenizerAnonymousInnerClassHelper | |
TestPositionIncrement.AnonymousClassAnalyzer | |
TestPositionIncrement.AnonymousClassAnalyzer.AnonymousClassTokenStream | |
TestPositionIncrement.StopWhitespaceAnalyzer | |
TestPositiveScoresOnlyCollector | |
TestPositiveScoresOnlyCollector.SimpleScorer | |
TestPrefixFilter | |
TestPrefixInBooleanQuery | |
TestPrefixQuery | |
TestPrefixQuery_ | |
TestPrefixRandom | |
TestPrefixRandom.DumbPrefixQuery | a stupid prefix query that just blasts thru the terms |
TestPrefixRandom.DumbPrefixQuery.SimplePrefixTermsEnum | |
TestQueryTermVector | |
TestQueryWrapperFilter | |
TestRangeQuery | |
TestRegexpQuery | |
TestRegexpQuery.AutomatonProviderAnonymousInnerClassHelper | |
TestRegexpRandom | |
TestRegexpRandom2 | |
TestRegexpRandom2.DumbRegexpQuery | a stupid regexp query that just blasts thru the terms |
TestRegexpRandom2.DumbRegexpQuery.SimpleAutomatonTermsEnum | |
TestRemoteSearchable | |
TestScoreCachingWrappingScorer | |
TestScoreCachingWrappingScorer.ScoreCachingCollector | |
TestScoreCachingWrappingScorer.SimpleScorer | |
TestScorerPerf | |
TestScorerPerf.AnonymousClassFilter | |
TestScorerPerf.CountingHitCollector | |
TestScorerPerf.FilterAnonymousInnerClassHelper | |
TestScorerPerf.MatchingHitCollector | |
TestSearchAfter | |
TestSearchWithThreads | |
TestSearchWithThreads.ThreadAnonymousInnerClassHelper | |
TestSearcherManager | |
TestSearcherManager.RefreshListenerAnonymousInnerClassHelper | |
TestSearcherManager.RunnableAnonymousInnerClassHelper | |
TestSearcherManager.SearcherFactoryAnonymousInnerClassHelper | |
TestSearcherManager.SearcherFactoryAnonymousInnerClassHelper2 | |
TestSearcherManager.SearcherFactoryAnonymousInnerClassHelper3 | |
TestSearcherManager.ThreadAnonymousInnerClassHelper | |
TestSearcherManager.ThreadAnonymousInnerClassHelper2 | |
TestSetNorm | |
TestSetNorm.AnonymousClassCollector | |
TestSetNorm.AnonymousClassHitCollector | |
TestShardSearching | |
TestShardSearching.PreviousSearchState | |
TestSimilarity | |
TestSimilarity.AnonymousClassCollector | |
TestSimilarity.AnonymousClassCollector1 | |
TestSimilarity.AnonymousClassCollector2 | |
TestSimilarity.AnonymousClassCollector3 | |
TestSimilarity.AnonymousClassHitCollector | |
TestSimilarity.AnonymousClassHitCollector1 | |
TestSimilarity.AnonymousClassHitCollector2 | |
TestSimilarity.AnonymousClassHitCollector3 | |
TestSimilarity.AnonymousIDFExplanation | |
TestSimilarity.SimpleSimilarity | |
TestSimpleExplanations | |
TestSimpleExplanationsOfNonMatches | |
TestSimpleFacetedSearch | |
TestSloppyPhraseQuery | |
TestSloppyPhraseQuery.CollectorAnonymousInnerClassHelper | |
TestSloppyPhraseQuery.MaxFreqCollector | |
TestSort | |
TestSort.AnonymousClassByteParser | |
TestSort.AnonymousClassDoubleParser | |
TestSort.AnonymousClassFilter | |
TestSort.AnonymousClassFloatParser | |
TestSort.AnonymousClassIntParser | |
TestSort.AnonymousClassLongParser | |
TestSort.AnonymousClassShortParser | |
TestSort.ByteParserAnonymousInnerClassHelper | |
TestSort.DoubleParserAnonymousInnerClassHelper | |
TestSort.FloatParserAnonymousInnerClassHelper | |
TestSort.IntParserAnonymousInnerClassHelper | |
TestSort.LongParserAnonymousInnerClassHelper | |
TestSort.MyFieldComparator | |
TestSort.MyFieldComparator.AnonymousClassIntParser1 | |
TestSort.MyFieldComparatorSource | |
TestSort.ShortParserAnonymousInnerClassHelper | |
TestSpanQueryFilter | |
TestSparseFacetedSearch | |
TestSubScorerFreqs | |
TestSubScorerFreqs.CountingCollector | |
TestTermRangeFilter | |
TestTermRangeQuery | |
TestTermRangeQuery.SingleCharAnalyzer | |
TestTermRangeQuery.SingleCharAnalyzer.SingleCharTokenizer | |
TestTermScorer | |
TestTermScorer.AnonymousClassCollector | |
TestTermScorer.TestHit | |
TestTermVectors | |
TestThreadSafe | |
TestThreadSafe.Thr | |
TestThreadSafe.Thr.AnonymousClassFieldSelector | |
TestTimeLimitingCollector | |
TestTimeLimitingCollector.AnonymousClassThread | |
TestTimeLimitingCollector.MyHitCollector | |
TestTimeLimitingCollector.ThreadClassAnonymousHelper | |
TestTopDocsMerge | |
TestTopDocsMerge.ShardSearcher | |
TestTopFieldCollector | |
TestTopScoreDocCollector | |
TestTotalHitCountCollector | |
TestWildcard | |
TestWildcardRandom | |
TimeLimitingCollector | The TimeLimitingCollector is used to timeout search requests that take longer than the maximum allowed search time limit. After this time is exceeded, the search thread is stopped by throwing a TimeExceededException. |
TimeLimitingCollector.TimeExceededException | |
TimeLimitingCollector.TimerThread | Thread used to timeout search requests. Can be stopped completely with TimerThread#stopTimer() @lucene.experimental |
TimeLimitingCollector.TimerThreadHolder | |
Weight |