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);
}