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;
if (!flatQueries.Contains(flat)) // LUCENENET specific - set semantics, but this is a list
{
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
}
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);
}
}
}
public virtual Query VisitDisjunctionMaxQuery(DisjunctionMaxQuery disjunctionMaxq)
{
throw new NotImplementedException();
}
public override Query VisitDisjunctionMaxQuery(DisjunctionMaxQuery disjunctionMaxq)
{
throw new NotImplementedException();
}
public virtual Query VisitDisjunctionMaxQuery(DisjunctionMaxQuery disjunctionMaxq) { throw new NotSupportedException(); }
