public Result Search (string term, int count, int start) { try { Query q1 = Parse (term, "hottext", true); Query q2 = Parse (term, "text", false); q2.SetBoost (0.7f); Query q3 = Parse (term, "examples", false); q3.SetBoost (0.5f); BooleanQuery q = new BooleanQuery(); q.Add (q1, BooleanClause.Occur.SHOULD); q.Add (q2, BooleanClause.Occur.SHOULD); q.Add (q3, BooleanClause.Occur.SHOULD); TopDocs top = SearchInternal (q, count, start); Result r = new Result (term, searcher, top.ScoreDocs); Results.Add (r); return r; } catch (IOException) { Console.WriteLine ("No index in {0}", dir); return null; } }
public override Query Rewrite(IndexReader reader) { if (!termLongEnough) { // can only match if it's exact return new TermQuery(term); } FilteredTermEnum enumerator = GetEnum(reader); int maxClauseCount = BooleanQuery.GetMaxClauseCount(); ScoreTermQueue stQueue = new ScoreTermQueue(maxClauseCount); ScoreTerm reusableST = null; try { do { float score = 0.0f; Term t = enumerator.Term(); if (t != null) { score = enumerator.Difference(); if (reusableST == null) { reusableST = new ScoreTerm(t, score); } else if (score >= reusableST.score) { // reusableST holds the last "rejected" entry, so, if // this new score is not better than that, there's no // need to try inserting it reusableST.score = score; reusableST.term = t; } else { continue; } reusableST = (ScoreTerm) stQueue.InsertWithOverflow(reusableST); } } while (enumerator.Next()); } finally { enumerator.Close(); } BooleanQuery query = new BooleanQuery(true); int size = stQueue.Size(); for (int i = 0; i < size; i++) { ScoreTerm st = (ScoreTerm) stQueue.Pop(); TermQuery tq = new TermQuery(st.term); // found a match tq.SetBoost(GetBoost() * st.score); // set the boost query.Add(tq, BooleanClause.Occur.SHOULD); // add to query } return query; }
public override Query Rewrite(IndexReader reader, MultiTermQuery query) { // Get the enum and start visiting terms. If we // exhaust the enum before hitting either of the // cutoffs, we use ConstantBooleanQueryRewrite; else, // ConstantFilterRewrite: System.Collections.ArrayList pendingTerms = new System.Collections.ArrayList(); int docCountCutoff = (int) ((docCountPercent / 100.0) * reader.MaxDoc()); int termCountLimit = System.Math.Min(BooleanQuery.GetMaxClauseCount(), termCountCutoff); int docVisitCount = 0; FilteredTermEnum enumerator = query.GetEnum(reader); try { while (true) { Term t = enumerator.Term(); if (t != null) { pendingTerms.Add(t); // Loading the TermInfo from the terms dict here // should not be costly, because 1) the // query/filter will load the TermInfo when it // runs, and 2) the terms dict has a cache: docVisitCount += reader.DocFreq(t); } if (pendingTerms.Count >= termCountLimit || docVisitCount >= docCountCutoff) { // Too many terms -- make a filter. Query result = new ConstantScoreQuery(new MultiTermQueryWrapperFilter(query)); result.SetBoost(query.GetBoost()); return result; } else if (!enumerator.Next()) { // Enumeration is done, and we hit a small // enough number of terms & docs -- just make a // BooleanQuery, now System.Collections.IEnumerator it = pendingTerms.GetEnumerator(); BooleanQuery bq = new BooleanQuery(true); while (it.MoveNext()) { TermQuery tq = new TermQuery((Term) it.Current); bq.Add(tq, BooleanClause.Occur.SHOULD); } // Strip scores Query result = new ConstantScoreQuery(new QueryWrapperFilter(bq)); result.SetBoost(query.GetBoost()); query.IncTotalNumberOfTerms(pendingTerms.Count); return result; } } } finally { enumerator.Close(); } }
public override Query Rewrite(IndexReader reader, MultiTermQuery query) { FilteredTermEnum enumerator = query.GetEnum(reader); BooleanQuery result = new BooleanQuery(true); int count = 0; try { do { Term t = enumerator.Term(); if (t != null) { TermQuery tq = new TermQuery(t); // found a match tq.SetBoost(query.GetBoost() * enumerator.Difference()); // set the boost result.Add(tq, BooleanClause.Occur.SHOULD); // add to query count++; } } while (enumerator.Next()); } finally { enumerator.Close(); } query.IncTotalNumberOfTerms(count); return result; }
/// <summary>Expert: merges the clauses of a set of BooleanQuery's into a single /// BooleanQuery. /// /// <p/>A utility for use by {@link #Combine(Query[])} implementations. /// </summary> public static Query MergeBooleanQueries(BooleanQuery[] queries) { System.Collections.Hashtable allClauses = new System.Collections.Hashtable(); for (int i = 0; i < queries.Length; i++) { BooleanClause[] clauses = queries[i].GetClauses(); for (int j = 0; j < clauses.Length; j++) { SupportClass.CollectionsHelper.AddIfNotContains(allClauses, clauses[j]); } } bool coordDisabled = queries.Length == 0?false:queries[0].IsCoordDisabled(); BooleanQuery result = new BooleanQuery(coordDisabled); System.Collections.IEnumerator i2 = allClauses.GetEnumerator(); while (i2.MoveNext()) { result.Add((BooleanClause) i2.Current); } return result; }
/// <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; }
public override Query Rewrite(IndexReader reader) { if (termArrays.Count == 1) { // optimize one-term case Term[] terms = (Term[]) termArrays[0]; BooleanQuery boq = new BooleanQuery(true); for (int i = 0; i < terms.Length; i++) { boq.Add(new TermQuery(terms[i]), BooleanClause.Occur.SHOULD); } boq.SetBoost(GetBoost()); return boq; } else { return this; } }