int termOrPhraseNumber; // used for colored tag support
public FieldQuery(Query query, bool phraseHighlight, bool fieldMatch)
{
this.fieldMatch = fieldMatch;
Dictionary <Query, Query> flatQueries = new Dictionary <Query, Query>();
flatten(query, flatQueries);
SaveTerms(flatQueries);
Dictionary <Query, Query> expandQueries = expand(flatQueries);
foreach (Query flatQuery in expandQueries.Keys)
{
QueryPhraseMap rootMap = getRootMap(flatQuery);
rootMap.Add(flatQuery);
if (!phraseHighlight && flatQuery is PhraseQuery)
{
PhraseQuery pq = (PhraseQuery)flatQuery;
if (pq.GetTerms().Length > 1)
{
foreach (Term term in pq.GetTerms())
{
rootMap.AddTerm(term.Text, flatQuery.Boost);
}
}
}
}
}
internal FieldQuery(Query query, IndexReader reader, bool phraseHighlight, bool fieldMatch)
{
this.fieldMatch = fieldMatch;
// LUCENENET NOTE: LinkedHashSet cares about insertion order
ISet <Query> flatQueries = new JCG.LinkedHashSet <Query>();
Flatten(query, reader, flatQueries);
SaveTerms(flatQueries, reader);
ICollection <Query> expandQueries = Expand(flatQueries);
foreach (Query flatQuery in expandQueries)
{
QueryPhraseMap rootMap = GetRootMap(flatQuery);
rootMap.Add(flatQuery, reader);
if (!phraseHighlight && flatQuery is PhraseQuery)
{
PhraseQuery pq = (PhraseQuery)flatQuery;
if (pq.GetTerms().Length > 1)
{
foreach (Term term in pq.GetTerms())
{
rootMap.AddTerm(term, flatQuery.Boost);
}
}
}
}
}
/// <summary>
/// Return 'key' string. 'key' is the field name of the <see cref="Query"/>.
/// If not fieldMatch, 'key' will be null.
/// </summary>
private string GetKey(Query query)
{
if (!fieldMatch)
{
return(null);
}
if (query is TermQuery)
{
return(((TermQuery)query).Term.Field);
}
else if (query is PhraseQuery)
{
PhraseQuery pq = (PhraseQuery)query;
Term[] terms = pq.GetTerms();
return(terms[0].Field);
}
else if (query is MultiTermQuery)
{
return(((MultiTermQuery)query).Field);
}
else
{
throw new Exception("query \"" + query.ToString() + "\" must be flatten first.");
}
}
public override Query VisitPhraseQuery(PhraseQuery phraseq)
{
var terms = phraseq.GetTerms();
PhraseQuery newQuery = null;
var index = 0;
var count = terms.Length;
while (index < count)
{
var visitedTerm = VisitTerm(terms[index]);
if (newQuery != null)
{
if (visitedTerm != null)
newQuery.Add(visitedTerm);
}
else if (visitedTerm != terms[index])
{
newQuery = new PhraseQuery();
for (var i = 0; i < index; i++)
newQuery.Add(terms[i]);
if (visitedTerm != null)
newQuery.Add(visitedTerm);
}
index++;
}
if (newQuery != null)
{
if (newQuery.GetTerms().Length > 0)
return newQuery;
return null;
}
return phraseq;
}
public virtual Query VisitPhraseQuery(PhraseQuery phraseq)
{
var terms = phraseq.GetTerms();
PhraseQuery newQuery = null;
int index = 0;
int count = terms.Length;
while (index < count)
{
var visitedTerm = VisitTerm(terms[index]);
if (newQuery != null)
{
newQuery.Add(visitedTerm);
}
else if (visitedTerm != terms[index])
{
newQuery = new PhraseQuery();
for (int i = 0; i < index; i++)
{
newQuery.Add(terms[i]);
}
newQuery.Add(visitedTerm);
}
index++;
}
if (newQuery != null)
{
return(newQuery);
}
return(phraseq);
}
private BsonDocument VisitPhrase(PhraseQuery phraseQuery)
{
var terms = phraseQuery.GetTerms();
var doc = new BsonDocument
{
["path"] = GetPath(terms[0].Field),
};
if (terms.Length == 1)
{
doc["query"] = terms[0].Text;
}
else
{
doc["query"] = new BsonArray(terms.Select(x => x.Text));
}
if (phraseQuery.Slop != 0)
{
doc["slop"] = phraseQuery.Slop;
}
ApplyBoost(phraseQuery, doc);
return(new BsonDocument
{
["phrase"] = doc
});
}
/*
* Return 'key' string. 'key' is the field name of the Query.
* If not fieldMatch, 'key' will be null.
*/
private String GetKey(Query query)
{
if (!fieldMatch)
{
return(null);
}
if (query is TermQuery)
{
return(((TermQuery)query).Term.Field);
}
if (query is PrefixQuery)
{
return(((PrefixQuery)query).Prefix.Field);
}
if (query is PhraseQuery)
{
PhraseQuery pq = (PhraseQuery)query;
Term[] terms = pq.GetTerms();
return(terms[0].Field);
}
throw new ApplicationException("query \"" + query + "\" must be flatten first.");
}
public void Add(Query query)
{
if (query is TermQuery)
{
AddTerm(((TermQuery)query).Term.Text, query.Boost);
}
else if (query is PrefixQuery)
{
AddTerm(((PrefixQuery)query).Prefix.Text + "*", query.Boost);
}
else if (query is PhraseQuery)
{
PhraseQuery pq = (PhraseQuery)query;
Term[] terms = pq.GetTerms();
HashMap <String, QueryPhraseMap> map = subMap;
QueryPhraseMap qpm = null;
foreach (Term term in terms)
{
qpm = GetOrNewMap(map, term.Text);
map = qpm.subMap;
}
qpm.MarkTerminal(pq.Slop, pq.Boost);
}
else
{
throw new ApplicationException("query \"" + query.ToString() + "\" must be flatten first.");
}
}
private static void VisitQuery(PhraseQuery query, AzureQueryLogger.IndentedTextWriter writer)
{
writer.WriteLine("Slop: {0}", (object)query.Slop);
foreach (Term term in query.GetTerms())
{
AzureQueryLogger.VisitTerm(term, writer);
}
}
/*
* Check if PhraseQuery A and B have overlapped part.
*
* ex1) A="a b", B="b c" => overlap; expandQueries={"a b c"}
* ex2) A="b c", B="a b" => overlap; expandQueries={"a b c"}
* ex3) A="a b", B="c d" => no overlap; expandQueries={}
*/
private void CheckOverlap(Dictionary<Query,Query> expandQueries, PhraseQuery a, PhraseQuery b)
{
if (a.GetSlop() != b.GetSlop()) return;
Term[] ats = a.GetTerms();
Term[] bts = b.GetTerms();
if (fieldMatch && !ats[0].Field().Equals(bts[0].Field())) return;
CheckOverlap(expandQueries, ats, bts, a.GetSlop(), a.GetBoost());
CheckOverlap(expandQueries, bts, ats, b.GetSlop(), b.GetBoost());
}
public void flatten(Query sourceQuery, Dictionary<Query,Query> flatQueries)
{
if (sourceQuery is BooleanQuery)
{
BooleanQuery bq = (BooleanQuery)sourceQuery;
foreach (BooleanClause clause in bq.GetClauses())
{
if (!clause.IsProhibited())
flatten(clause.GetQuery(), flatQueries);
}
}
else if (sourceQuery is DisjunctionMaxQuery)
{
DisjunctionMaxQuery dmq = (DisjunctionMaxQuery)sourceQuery;
System.Collections.IEnumerator en = dmq.Iterator();
while (en.MoveNext())
{
Query query = (Query)en.Current;
flatten(query, flatQueries);
}
}
else if (sourceQuery is TermQuery)
{
if (!flatQueries.ContainsKey(sourceQuery))
flatQueries.Add(sourceQuery, sourceQuery);
}
else if (sourceQuery is PhraseQuery)
{
if (!flatQueries.ContainsKey(sourceQuery))
{
PhraseQuery pq = (PhraseQuery)sourceQuery;
if (pq.GetTerms().Length > 1)
flatQueries.Add(pq, pq);
else if (pq.GetTerms().Length == 1)
{
Query q = new TermQuery(pq.GetTerms()[0]);
flatQueries.Add(q, q);
}
}
}
// else discard queries
}
private SectionSearchQueryPlan TranslatePhraseQuery(PhraseQuery query)
{
Term[] terms = query.GetTerms();
TermNode[] nodes = new TermNode[terms.Length];
int[] positions = query.GetPositions();
for (int i = 0; i < terms.Length; i++)
{
nodes[i] = new TermNode(terms[i], positions[i], m_reader);
}
return(new PhraseNode(nodes, m_reader));
}
/*
* Return 'key' string. 'key' is the field name of the Query.
* If not fieldMatch, 'key' will be null.
*/
private String GetKey(Query query)
{
if (!fieldMatch) return null;
if (query is TermQuery)
return ((TermQuery)query).GetTerm().Field();
else if (query is PhraseQuery)
{
PhraseQuery pq = (PhraseQuery)query;
Term[] terms = pq.GetTerms();
return terms[0].Field();
}
else
throw new System.ApplicationException("query \"" + query.ToString() + "\" must be flatten first.");
}
/*
* Check if PhraseQuery A and B have overlapped part.
*
* ex1) A="a b", B="b c" => overlap; expandQueries={"a b c"}
* ex2) A="b c", B="a b" => overlap; expandQueries={"a b c"}
* ex3) A="a b", B="c d" => no overlap; expandQueries={}
*/
private void CheckOverlap(Dictionary <Query, Query> expandQueries, PhraseQuery a, PhraseQuery b)
{
if (a.Slop != b.Slop)
{
return;
}
Term[] ats = a.GetTerms();
Term[] bts = b.GetTerms();
if (fieldMatch && !ats[0].Field.Equals(bts[0].Field))
{
return;
}
CheckOverlap(expandQueries, ats, bts, a.Slop, a.Boost);
CheckOverlap(expandQueries, bts, ats, b.Slop, b.Boost);
}
/// <summary>
/// Check if <see cref="PhraseQuery"/> A and B have overlapped part.
///
/// <code>
/// ex1) A="a b", B="b c" => overlap; expandQueries={"a b c"}
/// ex2) A="b c", B="a b" => overlap; expandQueries={"a b c"}
/// ex3) A="a b", B="c d" => no overlap; expandQueries={}
/// </code>
/// </summary>
private void CheckOverlap(ICollection <Query> expandQueries, PhraseQuery a, PhraseQuery b)
{
if (a.Slop != b.Slop)
{
return;
}
Term[] ats = a.GetTerms();
Term[] bts = b.GetTerms();
if (fieldMatch && !ats[0].Field.Equals(bts[0].Field, StringComparison.Ordinal))
{
return;
}
CheckOverlap(expandQueries, ats, bts, a.Slop, a.Boost);
CheckOverlap(expandQueries, bts, ats, b.Slop, b.Boost);
}
public override Query VisitPhraseQuery(PhraseQuery phraseq)
{
var terms = phraseq.GetTerms();
var field = terms[0].Field();
_text.Append(field);
_text.Append(":\"");
var positions = new int[terms.Length];
for (var i = 0; i < positions.Length; i++)
positions[i] = i;
var pieces = new string[terms.Length];
for (var i = 0; i < terms.Length; i++)
{
var pos = positions[i];
var s = pieces[pos];
if (s == null)
s = (terms[i]).Text();
else
s += "|" + (terms[i]).Text();
pieces[pos] = s;
}
for (var i = 0; i < pieces.Length; i++)
{
if (i > 0)
_text.Append(' ');
var s = pieces[i];
if (s == null)
_text.Append('?');
else
_text.Append(s);
}
_text.Append("\"");
var slop = phraseq.GetSlop();
if (slop != 0)
{
_text.Append("~");
_text.Append(slop);
}
_text.Append(BoostToString(phraseq.GetBoost()));
return base.VisitPhraseQuery(phraseq);
}
public override Query VisitPhraseQuery(PhraseQuery phraseq)
{
_dump.Append("PhraseQ(");
var terms = phraseq.GetTerms();
PhraseQuery newQuery = null;
int index = 0;
int count = terms.Length;
while (index < count)
{
var visitedTerm = VisitTerm(terms[index]);
if (newQuery != null)
{
newQuery.Add(visitedTerm);
}
else if (visitedTerm != terms[index])
{
newQuery = new PhraseQuery();
for (int i = 0; i < index; i++)
{
newQuery.Add(terms[i]);
}
newQuery.Add(visitedTerm);
}
index++;
if (index < count)
{
_dump.Append(", ");
}
}
_dump.Append(", Slop:").Append(phraseq.GetSlop()).Append(BoostToString(phraseq)).Append(")");
if (newQuery != null)
{
return(newQuery);
}
return(phraseq);
}
private ParameterizedSql BuildPhrase(PhraseQuery phraseQuery)
{
var termsAdded = 0;
var field = "";
var queryStringBuilder = new StringBuilder();
foreach (var term in phraseQuery.GetTerms())
{
if (termsAdded == 0)
{
field = term.Field;
}
else if (termsAdded > 0)
{
queryStringBuilder.Append(" ");
}
queryStringBuilder.Append(term.Text);
termsAdded++;
}
Query query;
var queryString = queryStringBuilder.ToString();
if (queryString.Contains("?") || queryString.Contains("*"))
{
query = new WildcardQuery(new Term(field, queryString));
}
else
{
query = new TermQuery(new Term(field, queryString));
}
return(Build(query));
}
internal void Add(Query query, IndexReader reader)
{
if (query is TermQuery)
{
AddTerm(((TermQuery)query).Term, query.Boost);
}
else if (query is PhraseQuery)
{
PhraseQuery pq = (PhraseQuery)query;
Term[] terms = pq.GetTerms();
IDictionary <string, QueryPhraseMap> map = subMap;
QueryPhraseMap qpm = null;
foreach (Term term in terms)
{
qpm = GetOrNewMap(map, term.Text());
map = qpm.subMap;
}
qpm.MarkTerminal(pq.Slop, pq.Boost);
}
else
{
throw new Exception("query \"" + query.ToString() + "\" must be flatten first.");
}
}
public void flatten(Query sourceQuery, Dictionary <Query, Query> flatQueries)
{
if (sourceQuery is BooleanQuery)
{
BooleanQuery bq = (BooleanQuery)sourceQuery;
foreach (BooleanClause clause in bq.GetClauses())
{
if (!clause.IsProhibited)
{
flatten(clause.Query, flatQueries);
}
}
}
else if (sourceQuery is PrefixQuery)
{
if (!flatQueries.ContainsKey(sourceQuery))
{
flatQueries.Add(sourceQuery, sourceQuery);
}
}
else if (sourceQuery is DisjunctionMaxQuery)
{
DisjunctionMaxQuery dmq = (DisjunctionMaxQuery)sourceQuery;
foreach (Query query in dmq)
{
flatten(query, flatQueries);
}
}
else if (sourceQuery is TermQuery)
{
if (!flatQueries.ContainsKey(sourceQuery))
{
flatQueries.Add(sourceQuery, sourceQuery);
}
}
else if (sourceQuery is PhraseQuery)
{
if (!flatQueries.ContainsKey(sourceQuery))
{
PhraseQuery pq = (PhraseQuery)sourceQuery;
if (pq.GetTerms().Length > 1)
{
flatQueries.Add(pq, pq);
}
else if (pq.GetTerms().Length == 1)
{
Query q = new TermQuery(pq.GetTerms()[0]);
flatQueries.Add(q, q);
}
}
}
else
{
// Fallback to using extracted terms
ISet <Term> terms = SetFactory.CreateHashSet <Term>();
try
{
sourceQuery.ExtractTerms(terms);
}
catch (NotSupportedException)
{ // thrown by default impl
return; // ignore error and discard query
}
foreach (var term in terms)
{
flatten(new TermQuery(term), flatQueries);
}
}
}
private static string ExtractLuceneClauses(Query query, string inputQuery, List <BooleanClause> luceneClauses)
{
BooleanQuery boolQuery = query as BooleanQuery;
IEnumerable <Query> clauses = boolQuery == null ? new[] { query } : boolQuery.Clauses.Select(c => c.Query);
// Process the query to extract the "nuget query" part and the "lucene filters" part
StringBuilder nugetQuery = new StringBuilder();
foreach (Query q in clauses)
{
TermQuery tq = q as TermQuery;
bool handledQuery = false;
if (tq != null && !AllowedNuGetFields.Contains(tq.Term.Field))
{
// Ignore fields we don't accept in NuGet-style queries
// And, add in terms that aren't labelled with a field.
bool containsWhitespace = tq.Term.Text.Any(Char.IsWhiteSpace);
if (containsWhitespace)
{
nugetQuery.Append("\"");
}
nugetQuery.Append(tq.Term.Text);
if (containsWhitespace)
{
nugetQuery.Append("\"");
}
nugetQuery.Append(" ");
handledQuery = true;
}
else
{
PhraseQuery pq = q as PhraseQuery;
if (pq != null)
{
Term[] terms = pq.GetTerms();
string[] fieldNames = terms
.Select(t => t.Field)
.Distinct(StringComparer.OrdinalIgnoreCase)
.ToArray();
if (fieldNames.Length == 1 && !AllowedNuGetFields.Contains(fieldNames[0]))
{
// All the terms refer to the same field and it's
// not a valid NuGet-style field
nugetQuery.AppendFormat("\"{0}\"", String.Join(" ", terms.Select(t => t.Text)));
nugetQuery.Append(" ");
handledQuery = true;
}
}
}
// Convert the clause to a MUST-have clause
if (!handledQuery)
{
luceneClauses.Add(new BooleanClause(q, Occur.MUST));
}
}
if (nugetQuery.Length > 0)
{
nugetQuery.Length -= 1; // Strip trailing space.
}
return(nugetQuery.ToString());
}
/// <summary>
/// Fills a <c>Map</c> with <see cref="WeightedSpanTerm"/>s using the terms from the supplied <c>Query</c>.
/// </summary>
/// <param name="query">Query to extract Terms from</param>
/// <param name="terms">Map to place created WeightedSpanTerms in</param>
private void Extract(Query query, IDictionary <String, WeightedSpanTerm> terms)
{
if (query is BooleanQuery)
{
BooleanClause[] queryClauses = ((BooleanQuery)query).GetClauses();
for (int i = 0; i < queryClauses.Length; i++)
{
if (!queryClauses[i].IsProhibited)
{
Extract(queryClauses[i].Query, terms);
}
}
}
else if (query is PhraseQuery)
{
PhraseQuery phraseQuery = ((PhraseQuery)query);
Term[] phraseQueryTerms = phraseQuery.GetTerms();
SpanQuery[] clauses = new SpanQuery[phraseQueryTerms.Length];
for (int i = 0; i < phraseQueryTerms.Length; i++)
{
clauses[i] = new SpanTermQuery(phraseQueryTerms[i]);
}
int slop = phraseQuery.Slop;
int[] positions = phraseQuery.GetPositions();
// add largest position increment to slop
if (positions.Length > 0)
{
int lastPos = positions[0];
int largestInc = 0;
int sz = positions.Length;
for (int i = 1; i < sz; i++)
{
int pos = positions[i];
int inc = pos - lastPos;
if (inc > largestInc)
{
largestInc = inc;
}
lastPos = pos;
}
if (largestInc > 1)
{
slop += largestInc;
}
}
bool inorder = slop == 0;
SpanNearQuery sp = new SpanNearQuery(clauses, slop, inorder);
sp.Boost = query.Boost;
ExtractWeightedSpanTerms(terms, sp);
}
else if (query is TermQuery)
{
ExtractWeightedTerms(terms, query);
}
else if (query is SpanQuery)
{
ExtractWeightedSpanTerms(terms, (SpanQuery)query);
}
else if (query is FilteredQuery)
{
Extract(((FilteredQuery)query).Query, terms);
}
else if (query is DisjunctionMaxQuery)
{
foreach (var q in ((DisjunctionMaxQuery)query))
{
Extract(q, terms);
}
}
else if (query is MultiTermQuery && expandMultiTermQuery)
{
MultiTermQuery mtq = ((MultiTermQuery)query);
if (mtq.RewriteMethod != MultiTermQuery.SCORING_BOOLEAN_QUERY_REWRITE)
{
mtq = (MultiTermQuery)mtq.Clone();
mtq.RewriteMethod = MultiTermQuery.SCORING_BOOLEAN_QUERY_REWRITE;
query = mtq;
}
FakeReader fReader = new FakeReader();
MultiTermQuery.SCORING_BOOLEAN_QUERY_REWRITE.Rewrite(fReader, mtq);
if (fReader.Field != null)
{
IndexReader ir = GetReaderForField(fReader.Field);
Extract(query.Rewrite(ir), terms);
}
}
else if (query is MultiPhraseQuery)
{
MultiPhraseQuery mpq = (MultiPhraseQuery)query;
IList <Term[]> termArrays = mpq.GetTermArrays();
int[] positions = mpq.GetPositions();
if (positions.Length > 0)
{
int maxPosition = positions[positions.Length - 1];
for (int i = 0; i < positions.Length - 1; ++i)
{
if (positions[i] > maxPosition)
{
maxPosition = positions[i];
}
}
var disjunctLists = new List <SpanQuery> [maxPosition + 1];
int distinctPositions = 0;
for (int i = 0; i < termArrays.Count; ++i)
{
Term[] termArray = termArrays[i];
List <SpanQuery> disjuncts = disjunctLists[positions[i]];
if (disjuncts == null)
{
disjuncts = (disjunctLists[positions[i]] = new List <SpanQuery>(termArray.Length));
++distinctPositions;
}
for (int j = 0; j < termArray.Length; ++j)
{
disjuncts.Add(new SpanTermQuery(termArray[j]));
}
}
int positionGaps = 0;
int position = 0;
SpanQuery[] clauses = new SpanQuery[distinctPositions];
for (int i = 0; i < disjunctLists.Length; ++i)
{
List <SpanQuery> disjuncts = disjunctLists[i];
if (disjuncts != null)
{
clauses[position++] = new SpanOrQuery(disjuncts.ToArray());
}
else
{
++positionGaps;
}
}
int slop = mpq.Slop;
bool inorder = (slop == 0);
SpanNearQuery sp = new SpanNearQuery(clauses, slop + positionGaps, inorder);
sp.Boost = query.Boost;
ExtractWeightedSpanTerms(terms, sp);
}
}
}
public override Query VisitPhraseQuery(PhraseQuery phraseq)
{
var terms = phraseq.GetTerms();
var field = terms[0].Field();
_text.Append(field);
_text.Append(":\"");
var positions = new int[terms.Length];
for (int i = 0; i < positions.Length; i++)
{
positions[i] = i;
}
var pieces = new string[terms.Length];
for (int i = 0; i < terms.Length; i++)
{
int pos = ((System.Int32)positions[i]);
System.String s = pieces[pos];
if (s == null)
{
s = (terms[i]).Text();
}
else
{
s += "|" + (terms[i]).Text();
}
pieces[pos] = s;
}
for (int i = 0; i < pieces.Length; i++)
{
if (i > 0)
{
_text.Append(' ');
}
System.String s = pieces[i];
if (s == null)
{
_text.Append('?');
}
else
{
_text.Append(s);
}
}
_text.Append("\"");
var slop = phraseq.GetSlop();
if (slop != 0)
{
_text.Append("~");
_text.Append(slop);
}
_text.Append(BoostToString(phraseq.GetBoost()));
return(base.VisitPhraseQuery(phraseq));
}
/// <summary>
/// Fills a <see cref="T:IDictionary{string, WeightedSpanTerm}"/> with <see cref="WeightedSpanTerm"/>s using the terms from the supplied <paramref name="query"/>.
/// </summary>
/// <param name="query"><see cref="Query"/> to extract Terms from</param>
/// <param name="terms">Map to place created <see cref="WeightedSpanTerm"/>s in</param>
/// <exception cref="System.IO.IOException">If there is a low-level I/O error</exception>
protected virtual void Extract(Query query, IDictionary <string, WeightedSpanTerm> terms)
{
if (query is BooleanQuery)
{
IList <BooleanClause> queryClauses = ((BooleanQuery)query).Clauses;
for (int i = 0; i < queryClauses.Count; i++)
{
if (!queryClauses[i].IsProhibited)
{
Extract(queryClauses[i].Query, terms);
}
}
}
else if (query is PhraseQuery)
{
PhraseQuery phraseQuery = (PhraseQuery)query;
Term[] phraseQueryTerms = phraseQuery.GetTerms();
SpanQuery[] clauses = new SpanQuery[phraseQueryTerms.Length];
for (int i = 0; i < phraseQueryTerms.Length; i++)
{
clauses[i] = new SpanTermQuery(phraseQueryTerms[i]);
}
int slop = phraseQuery.Slop;
int[] positions = phraseQuery.GetPositions();
// add largest position increment to slop
if (positions.Length > 0)
{
int lastPos = positions[0];
int largestInc = 0;
int sz = positions.Length;
for (int i = 1; i < sz; i++)
{
int pos = positions[i];
int inc = pos - lastPos;
if (inc > largestInc)
{
largestInc = inc;
}
lastPos = pos;
}
if (largestInc > 1)
{
slop += largestInc;
}
}
bool inorder = slop == 0;
SpanNearQuery sp = new SpanNearQuery(clauses, slop, inorder);
sp.Boost = query.Boost;
ExtractWeightedSpanTerms(terms, sp);
}
else if (query is TermQuery)
{
ExtractWeightedTerms(terms, query);
}
else if (query is SpanQuery)
{
ExtractWeightedSpanTerms(terms, (SpanQuery)query);
}
else if (query is FilteredQuery)
{
Extract(((FilteredQuery)query).Query, terms);
}
else if (query is ConstantScoreQuery)
{
Query q = ((ConstantScoreQuery)query).Query;
if (q != null)
{
Extract(q, terms);
}
}
else if (query is CommonTermsQuery)
{
// specialized since rewriting would change the result query
// this query is TermContext sensitive.
ExtractWeightedTerms(terms, query);
}
else if (query is DisjunctionMaxQuery)
{
foreach (var q in ((DisjunctionMaxQuery)query))
{
Extract(q, terms);
}
}
else if (query is MultiPhraseQuery)
{
MultiPhraseQuery mpq = (MultiPhraseQuery)query;
IList <Term[]> termArrays = mpq.GetTermArrays();
int[] positions = mpq.GetPositions();
if (positions.Length > 0)
{
int maxPosition = positions[positions.Length - 1];
for (int i = 0; i < positions.Length - 1; ++i)
{
if (positions[i] > maxPosition)
{
maxPosition = positions[i];
}
}
var disjunctLists = new List <SpanQuery> [maxPosition + 1];
int distinctPositions = 0;
for (int i = 0; i < termArrays.Count; ++i)
{
Term[] termArray = termArrays[i];
List <SpanQuery> disjuncts = disjunctLists[positions[i]];
if (disjuncts == null)
{
disjuncts = (disjunctLists[positions[i]] = new List <SpanQuery>(termArray.Length));
++distinctPositions;
}
foreach (var term in termArray)
{
disjuncts.Add(new SpanTermQuery(term));
}
}
int positionGaps = 0;
int position = 0;
SpanQuery[] clauses = new SpanQuery[distinctPositions];
foreach (var disjuncts in disjunctLists)
{
if (disjuncts != null)
{
clauses[position++] = new SpanOrQuery(disjuncts.ToArray());
}
else
{
++positionGaps;
}
}
int slop = mpq.Slop;
bool inorder = (slop == 0);
SpanNearQuery sp = new SpanNearQuery(clauses, slop + positionGaps, inorder);
sp.Boost = query.Boost;
ExtractWeightedSpanTerms(terms, sp);
}
}
else
{
Query origQuery = query;
if (query is MultiTermQuery)
{
if (!expandMultiTermQuery)
{
return;
}
MultiTermQuery copy = (MultiTermQuery)query.Clone();
copy.MultiTermRewriteMethod = MultiTermQuery.SCORING_BOOLEAN_QUERY_REWRITE;
origQuery = copy;
}
IndexReader reader = GetLeafContext().Reader;
Query rewritten = origQuery.Rewrite(reader);
if (rewritten != origQuery)
{
// only rewrite once and then flatten again - the rewritten query could have a speacial treatment
// if this method is overwritten in a subclass or above in the next recursion
Extract(rewritten, terms);
}
}
ExtractUnknownQuery(query, terms);
}
internal void Flatten(Query sourceQuery, IndexReader reader, ICollection <Query> flatQueries)
{
if (sourceQuery is BooleanQuery)
{
BooleanQuery bq = (BooleanQuery)sourceQuery;
foreach (BooleanClause clause in bq)
{
if (!clause.IsProhibited)
{
Flatten(ApplyParentBoost(clause.Query, bq), reader, flatQueries);
}
}
}
else if (sourceQuery is DisjunctionMaxQuery)
{
DisjunctionMaxQuery dmq = (DisjunctionMaxQuery)sourceQuery;
foreach (Query query in dmq)
{
Flatten(ApplyParentBoost(query, dmq), reader, flatQueries);
}
}
else if (sourceQuery is TermQuery)
{
if (!flatQueries.Contains(sourceQuery))
{
flatQueries.Add(sourceQuery);
}
}
else if (sourceQuery is PhraseQuery)
{
if (!flatQueries.Contains(sourceQuery)) // LUCENENET - set semantics, but this is a list. The original logic was already correct.
{
PhraseQuery pq = (PhraseQuery)sourceQuery;
if (pq.GetTerms().Length > 1)
{
flatQueries.Add(pq);
}
else if (pq.GetTerms().Length == 1)
{
Query flat = new TermQuery(pq.GetTerms()[0]);
flat.Boost = pq.Boost;
flatQueries.Add(flat);
}
}
}
else if (sourceQuery is ConstantScoreQuery)
{
Query q = ((ConstantScoreQuery)sourceQuery).Query;
if (q != null)
{
Flatten(ApplyParentBoost(q, sourceQuery), reader, flatQueries);
}
}
else if (sourceQuery is FilteredQuery)
{
Query q = ((FilteredQuery)sourceQuery).Query;
if (q != null)
{
Flatten(ApplyParentBoost(q, sourceQuery), reader, flatQueries);
}
}
else if (reader != null)
{
Query query = sourceQuery;
if (sourceQuery is MultiTermQuery)
{
MultiTermQuery copy = (MultiTermQuery)sourceQuery.Clone();
copy.MultiTermRewriteMethod = new MultiTermQuery.TopTermsScoringBooleanQueryRewrite(MAX_MTQ_TERMS);
query = copy;
}
Query rewritten = query.Rewrite(reader);
if (rewritten != query)
{
// only rewrite once and then flatten again - the rewritten query could have a speacial treatment
// if this method is overwritten in a subclass.
Flatten(rewritten, reader, flatQueries);
}
// if the query is already rewritten we discard it
}
// else discard queries
}
