public /*internal*/ bool debugCheckedForDeletions = false; // for test purposes. internal Hits(Searcher s, Query q, Filter f) { weight = q.Weight(s); searcher = s; filter = f; nDeletions = CountDeletions(s); GetMoreDocs(50); // retrieve 100 initially lengthAtStart = length; }
TopDocs SearchInternal (Query q, int count, int start) { // Easy path that doesn't involve creating a Collector ourselves // watch for Lucene.NET improvement on that (like searcher.SearchAfter) if (start == 0) return searcher.Search (q, count); var weight = searcher.CreateWeight (q); // TODO: reuse weight instead of query var collector = TopScoreDocCollector.create (start + count + 1, weight.ScoresDocsOutOfOrder()); searcher.Search (q, collector); return collector.TopDocs (start, count); }
public override Query Rewrite(Query original) { Query query = original; for (Query rewrittenQuery = query.Rewrite(reader); rewrittenQuery != query; rewrittenQuery = query.Rewrite(reader)) { query = rewrittenQuery; } return query; }
public virtual Hits Search(Query query, Filter filter, Sort sort) { return new Hits(this, query, filter, sort); }
/// <summary> Constructs a new query which applies a filter to the results of the original query. /// Filter.getDocIdSet() will be called every time this query is used in a search. /// </summary> /// <param name="query"> Query to be filtered, cannot be <code>null</code>. /// </param> /// <param name="filter">Filter to apply to query results, cannot be <code>null</code>. /// </param> public FilteredQuery(Query query, Filter filter) { this.query = query; this.filter = filter; }
/// <summary> Create weight in multiple index scenario. /// /// Distributed query processing is done in the following steps: /// 1. rewrite query /// 2. extract necessary terms /// 3. collect dfs for these terms from the Searchables /// 4. create query weight using aggregate dfs. /// 5. distribute that weight to Searchables /// 6. merge results /// /// Steps 1-4 are done here, 5+6 in the search() methods /// /// </summary> /// <returns> rewritten queries /// </returns> public /*protected internal*/ override Weight CreateWeight(Query original) { // step 1 Query rewrittenQuery = Rewrite(original); // step 2 System.Collections.Hashtable terms = new System.Collections.Hashtable(); rewrittenQuery.ExtractTerms(terms); // step3 Term[] allTermsArray = new Term[terms.Count]; int index = 0; System.Collections.IEnumerator e = terms.Keys.GetEnumerator(); while (e.MoveNext()) allTermsArray[index++] = e.Current as Term; int[] aggregatedDfs = new int[terms.Count]; for (int i = 0; i < searchables.Length; i++) { int[] dfs = searchables[i].DocFreqs(allTermsArray); for (int j = 0; j < aggregatedDfs.Length; j++) { aggregatedDfs[j] += dfs[j]; } } System.Collections.Hashtable dfMap = new System.Collections.Hashtable(); for (int i = 0; i < allTermsArray.Length; i++) { dfMap[allTermsArray[i]] = (System.Int32) aggregatedDfs[i]; } // step4 int numDocs = MaxDoc(); CachedDfSource cacheSim = new CachedDfSource(dfMap, numDocs, GetSimilarity()); return rewrittenQuery.Weight(cacheSim); }
/// <summary>Constructs a BooleanClause.</summary> public BooleanClause(Query query, Occur occur) { this.query = query; this.occur = occur; }
/// <summary>Expert: called when re-writing queries under MultiSearcher. /// /// Create a single query suitable for use by all subsearchers (in 1-1 /// correspondence with queries). This is an optimization of the OR of /// all queries. We handle the common optimization cases of equal /// queries and overlapping clauses of boolean OR queries (as generated /// by MultiTermQuery.rewrite()). /// Be careful overriding this method as queries[0] determines which /// method will be called and is not necessarily of the same type as /// the other queries. /// </summary> public virtual Query Combine(Query[] queries) { System.Collections.Hashtable uniques = new System.Collections.Hashtable(); for (int i = 0; i < queries.Length; i++) { Query query = queries[i]; BooleanClause[] clauses = null; // check if we can split the query into clauses bool splittable = (query is BooleanQuery); if (splittable) { BooleanQuery bq = (BooleanQuery) query; splittable = bq.IsCoordDisabled(); clauses = bq.GetClauses(); for (int j = 0; splittable && j < clauses.Length; j++) { splittable = (clauses[j].GetOccur() == BooleanClause.Occur.SHOULD); } } if (splittable) { for (int j = 0; j < clauses.Length; j++) { SupportClass.CollectionsHelper.AddIfNotContains(uniques, clauses[j].GetQuery()); } } else { SupportClass.CollectionsHelper.AddIfNotContains(uniques, query); } } // optimization: if we have just one query, just return it if (uniques.Count == 1) { foreach (object key in uniques.Keys) { return (Query) key; } } BooleanQuery result = new BooleanQuery(true); foreach (object key in uniques.Keys) { result.Add((Query) key, BooleanClause.Occur.SHOULD); } return result; }
/// <summary>Search implementation with arbitrary sorting. Finds /// the top <code>n</code> hits for <code>query</code>, applying /// <code>filter</code> if non-null, and sorting the hits by the criteria in /// <code>sort</code>. /// /// <p/>NOTE: this does not compute scores by default; use /// {@link IndexSearcher#setDefaultFieldSortScoring} to enable scoring. /// /// </summary> /// <throws> BooleanQuery.TooManyClauses </throws> public virtual TopFieldDocs Search(Query query, Filter filter, int n, Sort sort) { return Search(CreateWeight(query), filter, n, sort); }
/// <summary>Returns an Explanation that describes how <code>doc</code> scored against /// <code>query</code>. /// /// <p/>This is intended to be used in developing Similarity implementations, /// and, for good performance, should not be displayed with every hit. /// Computing an explanation is as expensive as executing the query over the /// entire index. /// </summary> public virtual Explanation Explain(Query query, int doc) { return Explain(CreateWeight(query), doc); }
/// <summary> creates a weight for <code>query</code></summary> /// <returns> new weight /// </returns> public /*protected internal*/ virtual Weight CreateWeight(Query query) { return query.Weight(this); }
/// <summary>Finds the top <code>n</code> /// hits for <code>query</code>, applying <code>filter</code> if non-null. /// /// </summary> /// <throws> BooleanQuery.TooManyClauses </throws> public virtual TopDocs Search(Query query, Filter filter, int n) { return Search(CreateWeight(query), filter, n); }
/// <summary>Finds the top <code>n</code> /// hits for <code>query</code>. /// /// </summary> /// <throws> BooleanQuery.TooManyClauses </throws> public virtual TopDocs Search(Query query, int n) { return Search(query, null, n); }
/// <summary>Lower-level search API. /// /// <p/>{@link Collector#Collect(int)} is called for every matching /// document. /// <br/>Collector-based access to remote indexes is discouraged. /// /// <p/>Applications should only use this if they need <i>all</i> of the /// matching documents. The high-level search API ({@link /// Searcher#Search(Query, Filter, int)}) is usually more efficient, as it skips /// non-high-scoring hits. /// /// </summary> /// <param name="query">to match documents /// </param> /// <param name="filter">if non-null, used to permit documents to be collected. /// </param> /// <param name="results">to receive hits /// </param> /// <throws> BooleanQuery.TooManyClauses </throws> public virtual void Search(Query query, Filter filter, Collector results) { Search(CreateWeight(query), filter, results); }
public virtual void Search(Query query, Filter filter, HitCollector results) { Search(CreateWeight(query), filter, new HitCollectorWrapper(results)); }
/// <summary>Lower-level search API. /// /// <p/>{@link Collector#Collect(int)} is called for every matching document. /// /// <p/>Applications should only use this if they need <i>all</i> of the matching /// documents. The high-level search API ({@link Searcher#Search(Query, int)} /// ) is usually more efficient, as it skips non-high-scoring hits. /// <p/>Note: The <code>score</code> passed to this method is a raw score. /// In other words, the score will not necessarily be a float whose value is /// between 0 and 1. /// </summary> /// <throws> BooleanQuery.TooManyClauses </throws> public virtual void Search(Query query, Collector results) { Search(CreateWeight(query), null, results); }
/// <summary>Constructs a filter which only matches documents matching /// <code>query</code>. /// </summary> public QueryWrapperFilter(Query query) { this.query = query; }
/// <summary>Constructs a filter which only matches documents matching /// <code>query</code>. /// </summary> public QueryFilter(Query query):base(new QueryWrapperFilter(query)) { }
/// <summary>Adds a clause to a boolean query. /// /// </summary> /// <throws> TooManyClauses if the new number of clauses exceeds the maximum clause number </throws> /// <seealso cref="GetMaxClauseCount()"> /// </seealso> public virtual void Add(Query query, BooleanClause.Occur occur) { Add(new BooleanClause(query, occur)); }
public override Query Rewrite(Query query) { // this is a bit of a hack. We know that a query which // creates a Weight based on this Dummy-Searcher is // always already rewritten (see preparedWeight()). // Therefore we just return the unmodified query here return query; }
abstract public Query Rewrite(Query query);
public virtual void SetQuery(Query query) { this.query = query; }
public Hits Search(Query query) { return Search(query, (Filter) null); }
public virtual Hits Search(Query query, Filter filter) { return new Hits(this, query, filter); }
public override Query Rewrite(Query original) { Query[] queries = new Query[searchables.Length]; for (int i = 0; i < searchables.Length; i++) { queries[i] = searchables[i].Rewrite(original); } return queries[0].Combine(queries); }
public virtual Hits Search(Query query, Sort sort) { return new Hits(this, query, null, sort); }
/// <summary>Add a subquery to this disjunction</summary> /// <param name="query">the disjunct added /// </param> public virtual void Add(Query query) { disjuncts.Add(query); }
/* * TODO: this one could be parallelized too * @see Mono.Lucene.Net.Search.Searchable#rewrite(Mono.Lucene.Net.Search.Query) */ public override Query Rewrite(Query original) { return base.Rewrite(original); }