public override Query Rewrite(IndexReader reader, MultiTermQuery query)
{
Query result = new ConstantScoreQuery(new MultiTermQueryDocTermOrdsWrapperFilter(query));
result.Boost = query.Boost;
return(result);
}
public override Query Rewrite(IndexReader reader, MultiTermQuery query)
{
var result = GetTopLevelQuery();
ParallelArraysTermCollector col = new ParallelArraysTermCollector(this);
CollectTerms(reader, query, col);
int size = col.terms.Count;
if (size > 0)
{
int[] sort = col.terms.Sort(col.termsEnum.Comparer);
float[] boost = col.array.boost;
TermContext[] termStates = col.array.termState;
for (int i = 0; i < size; i++)
{
int pos = sort[i];
Term term = new Term(query.Field, col.terms.Get(pos, new BytesRef()));
if (Debugging.AssertsEnabled)
{
Debugging.Assert(reader.DocFreq(term) == termStates[pos].DocFreq);
}
AddClause(result, term, termStates[pos].DocFreq, query.Boost * boost[pos], termStates[pos]);
}
}
return(result);
}
public override bool Equals(object obj)
{
if (this == obj)
{
return(true);
}
if (obj == null)
{
return(false);
}
if (this.GetType() != obj.GetType())
{
return(false);
}
MultiTermQuery other = (MultiTermQuery)obj;
if (J2N.BitConversion.SingleToInt32Bits(Boost) != J2N.BitConversion.SingleToInt32Bits(other.Boost))
{
return(false);
}
if (!m_rewriteMethod.Equals(other.m_rewriteMethod))
{
return(false);
}
return(other.m_field == null ? m_field == null : other.m_field.Equals(m_field, StringComparison.Ordinal));
}
public override Query Rewrite(IndexReader reader, MultiTermQuery query)
{
BooleanQuery bq = (BooleanQuery)SCORING_BOOLEAN_QUERY_REWRITE.Rewrite(reader, query);
// strip the scores off
Query result = new ConstantScoreQuery(bq);
result.Boost = query.Boost;
return(result);
}
internal void CollectTerms(IndexReader reader, MultiTermQuery query, TermCollector collector)
{
IndexReaderContext topReaderContext = reader.Context;
IComparer <BytesRef> lastTermComp = null;
foreach (AtomicReaderContext context in topReaderContext.Leaves)
{
Fields fields = context.AtomicReader.Fields;
if (fields == null)
{
// reader has no fields
continue;
}
Terms terms = fields.GetTerms(query.m_field);
if (terms == null)
{
// field does not exist
continue;
}
TermsEnum termsEnum = GetTermsEnum(query, terms, collector.Attributes);
if (Debugging.AssertsEnabled)
{
Debugging.Assert(termsEnum != null);
}
if (termsEnum == TermsEnum.EMPTY)
{
continue;
}
// Check comparer compatibility:
IComparer <BytesRef> newTermComp = termsEnum.Comparer;
if (lastTermComp != null && newTermComp != null && newTermComp != lastTermComp)
{
throw new Exception("term comparer should not change between segments: " + lastTermComp + " != " + newTermComp);
}
lastTermComp = newTermComp;
collector.SetReaderContext(topReaderContext, context);
collector.SetNextEnum(termsEnum);
BytesRef bytes;
while ((bytes = termsEnum.Next()) != null)
{
if (!collector.Collect(bytes))
{
return; // interrupt whole term collection, so also don't iterate other subReaders
}
}
}
}
public override Query Rewrite(IndexReader reader, MultiTermQuery query)
{
int maxSize = Math.Min(size, MaxSize);
PriorityQueue <ScoreTerm> stQueue = new PriorityQueue <ScoreTerm>();
CollectTerms(reader, query, new TermCollectorAnonymousInnerClassHelper(this, maxSize, stQueue));
var q = GetTopLevelQuery();
ScoreTerm[] scoreTerms = stQueue.ToArray(/*new ScoreTerm[stQueue.size()]*/);
ArrayUtil.TimSort(scoreTerms, scoreTermSortByTermComp);
foreach (ScoreTerm st in scoreTerms)
{
Term term = new Term(query.m_field, st.Bytes);
Debug.Assert(reader.DocFreq(term) == st.TermState.DocFreq, "reader DF is " + reader.DocFreq(term) + " vs " + st.TermState.DocFreq + " term=" + term);
AddClause(q, term, st.TermState.DocFreq, query.Boost * st.Boost, st.TermState); // add to query
}
return(q);
}
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:
int docCountCutoff = (int)((docCountPercent / 100.0) * reader.MaxDoc);
int termCountLimit = Math.Min(BooleanQuery.MaxClauseCount, termCountCutoff);
CutOffTermCollector col = new CutOffTermCollector(docCountCutoff, termCountLimit);
CollectTerms(reader, query, col);
int size = col.pendingTerms.Count;
if (col.hasCutOff)
{
return(MultiTermQuery.CONSTANT_SCORE_FILTER_REWRITE.Rewrite(reader, query));
}
else
{
BooleanQuery bq = GetTopLevelQuery();
if (size > 0)
{
BytesRefHash pendingTerms = col.pendingTerms;
int[] sort = pendingTerms.Sort(col.termsEnum.Comparer);
for (int i = 0; i < size; i++)
{
int pos = sort[i];
// docFreq is not used for constant score here, we pass 1
// to explicitely set a fake value, so it's not calculated
AddClause(bq, new Term(query.m_field, pendingTerms.Get(pos, new BytesRef())), 1, 1.0f, col.array.termState[pos]);
}
}
// Strip scores
Query result = new ConstantScoreQuery(bq);
result.Boost = query.Boost;
return(result);
}
}
public override Query Rewrite(IndexReader reader, MultiTermQuery query)
{
int maxSize = Math.Min(size, MaxSize);
JCG.PriorityQueue <ScoreTerm> stQueue = new JCG.PriorityQueue <ScoreTerm>();
CollectTerms(reader, query, new TermCollectorAnonymousClass(maxSize, stQueue));
var q = GetTopLevelQuery();
ScoreTerm[] scoreTerms = stQueue.ToArray(/*new ScoreTerm[stQueue.Count]*/);
ArrayUtil.TimSort(scoreTerms, scoreTermSortByTermComp);
foreach (ScoreTerm st in scoreTerms)
{
Term term = new Term(query.m_field, st.Bytes);
if (Debugging.AssertsEnabled)
{
Debugging.Assert(reader.DocFreq(term) == st.TermState.DocFreq, "reader DF is {0} vs {1} term={2}", reader.DocFreq(term), st.TermState.DocFreq, term);
}
AddClause(q, term, st.TermState.DocFreq, query.Boost * st.Boost, st.TermState); // add to query
}
return(q);
}
/// <summary>
/// Wrap a <see cref="MultiTermQuery"/> as a <see cref="Filter"/>.
/// </summary>
protected internal MultiTermQueryDocTermOrdsWrapperFilter(MultiTermQuery query)
{
this.m_query = query;
}
/// <summary>
/// Wrap a <see cref="MultiTermQuery"/> as a Filter.
/// </summary>
protected internal MultiTermQueryFieldCacheWrapperFilter(MultiTermQuery query)
{
this.m_query = query;
}
/// <summary>
/// Returns the <see cref="MultiTermQuery"/>s <see cref="TermsEnum"/> </summary>
/// <seealso cref="MultiTermQuery.GetTermsEnum(Terms, AttributeSource)"/>
protected virtual TermsEnum GetTermsEnum(MultiTermQuery query, Terms terms, AttributeSource atts)
{
return(query.GetTermsEnum(terms, atts)); // allow RewriteMethod subclasses to pull a TermsEnum from the MTQ
}
public abstract Query Rewrite(IndexReader reader, MultiTermQuery query);
