public FieldCacheDocIdSetAnonymousInnerClassHelper(MultiTermQueryFieldCacheWrapperFilter outerInstance, int maxDoc, IBits acceptDocs, SortedDocValues fcsi, Int64BitSet termSet)
: base(maxDoc, acceptDocs)
{
this.outerInstance = outerInstance;
this.fcsi = fcsi;
this.termSet = termSet;
}
/// <summary>
/// Returns a DocIdSet with documents that should be permitted in search
/// results.
/// </summary>
public override DocIdSet GetDocIdSet(AtomicReaderContext context, IBits acceptDocs)
{
SortedDocValues fcsi = FieldCache.DEFAULT.GetTermsIndex((context.AtomicReader), m_query.m_field);
// Cannot use FixedBitSet because we require long index (ord):
Int64BitSet termSet = new Int64BitSet(fcsi.ValueCount);
TermsEnum termsEnum = m_query.GetTermsEnum(new TermsAnonymousInnerClassHelper(this, fcsi));
Debug.Assert(termsEnum != null);
if (termsEnum.Next() != null)
{
// fill into a bitset
do
{
long ord = termsEnum.Ord;
if (ord >= 0)
{
termSet.Set(ord);
}
} while (termsEnum.Next() != null);
}
else
{
return(null);
}
return(new FieldCacheDocIdSetAnonymousInnerClassHelper(this, context.Reader.MaxDoc, acceptDocs, fcsi, termSet));
}
public FieldCacheDocIdSetAnonymousInnerClassHelper(MultiTermQueryDocTermOrdsWrapperFilter outerInstance, int maxDoc, IBits acceptDocs, SortedSetDocValues docTermOrds, Int64BitSet termSet)
: base(maxDoc, acceptDocs)
{
this.outerInstance = outerInstance;
this.docTermOrds = docTermOrds;
this.termSet = termSet;
}
internal BitsFilteredTermsEnum(TermsEnum @in, Int64BitSet liveTerms)
: base(@in, false)
{
if (Debugging.AssertsEnabled)
{
Debugging.Assert(liveTerms != null);
}
this.liveTerms = liveTerms;
}
public override void AddSortedSetField(FieldInfo field, IEnumerable <BytesRef> values, IEnumerable <long?> docToOrdCount, IEnumerable <long?> ords)
{
long valueCount = 0;
BytesRef lastValue = null;
foreach (BytesRef b in values)
{
Debug.Assert(b != null);
Debug.Assert(b.IsValid());
if (valueCount > 0)
{
Debug.Assert(b.CompareTo(lastValue) > 0);
}
lastValue = BytesRef.DeepCopyOf(b);
valueCount++;
}
int docCount = 0;
long ordCount = 0;
Int64BitSet seenOrds = new Int64BitSet(valueCount);
using (IEnumerator <long?> ordIterator = ords.GetEnumerator())
{
foreach (long?v in docToOrdCount)
{
Debug.Assert(v != null);
int count = (int)v.Value;
Debug.Assert(count >= 0);
docCount++;
ordCount += count;
long lastOrd = -1;
for (int i = 0; i < count; i++)
{
ordIterator.MoveNext();
long?o = ordIterator.Current;
Debug.Assert(o != null);
long ord = o.Value;
Debug.Assert(ord >= 0 && ord < valueCount);
Debug.Assert(ord > lastOrd, "ord=" + ord + ",lastOrd=" + lastOrd);
seenOrds.Set(ord);
lastOrd = ord;
}
}
Debug.Assert(ordIterator.MoveNext() == false);
Debug.Assert(docCount == maxDoc);
Debug.Assert(seenOrds.Cardinality() == valueCount);
CheckIterator(values.GetEnumerator(), valueCount, false);
CheckIterator(docToOrdCount.GetEnumerator(), maxDoc, false);
CheckIterator(ords.GetEnumerator(), ordCount, false);
@in.AddSortedSetField(field, values, docToOrdCount, ords);
}
}
/// <summary>
/// Merges the sortedset docvalues from <paramref name="toMerge"/>.
/// <para>
/// The default implementation calls <see cref="AddSortedSetField(FieldInfo, IEnumerable{BytesRef}, IEnumerable{long?}, IEnumerable{long?})"/>, passing
/// an <see cref="IEnumerable{T}"/> that merges ordinals and values and filters deleted documents.</para>
/// </summary>
public virtual void MergeSortedSetField(FieldInfo fieldInfo, MergeState mergeState, IList <SortedSetDocValues> toMerge)
{
var readers = mergeState.Readers.ToArray();
var dvs = toMerge.ToArray();
// step 1: iterate thru each sub and mark terms still in use
var liveTerms = new TermsEnum[dvs.Length];
for (int sub = 0; sub < liveTerms.Length; sub++)
{
var reader = readers[sub];
var dv = dvs[sub];
var liveDocs = reader.LiveDocs;
if (liveDocs == null)
{
liveTerms[sub] = dv.GetTermsEnum();
}
else
{
var bitset = new Int64BitSet(dv.ValueCount);
for (int i = 0; i < reader.MaxDoc; i++)
{
if (liveDocs.Get(i))
{
dv.SetDocument(i);
long ord;
while ((ord = dv.NextOrd()) != SortedSetDocValues.NO_MORE_ORDS)
{
bitset.Set(ord);
}
}
}
liveTerms[sub] = new BitsFilteredTermsEnum(dv.GetTermsEnum(), bitset);
}
}
// step 2: create ordinal map (this conceptually does the "merging")
var map = new OrdinalMap(this, liveTerms);
// step 3: add field
AddSortedSetField(fieldInfo, GetMergeSortedSetValuesEnumerable(map, dvs),
// doc -> ord count
GetMergeSortedSetDocToOrdCountEnumerable(readers, dvs),
// ords
GetMergeSortedSetOrdsEnumerable(readers, dvs, map)
);
}
/// <summary>
/// Merges the sorted docvalues from <paramref name="toMerge"/>.
/// <para>
/// The default implementation calls <see cref="AddSortedField(FieldInfo, IEnumerable{BytesRef}, IEnumerable{long?})"/>, passing
/// an <see cref="IEnumerable{T}"/> that merges ordinals and values and filters deleted documents.</para>
/// </summary>
public virtual void MergeSortedField(FieldInfo fieldInfo, MergeState mergeState, IList <SortedDocValues> toMerge)
{
AtomicReader[] readers = mergeState.Readers.ToArray();
SortedDocValues[] dvs = toMerge.ToArray();
// step 1: iterate thru each sub and mark terms still in use
var liveTerms = new TermsEnum[dvs.Length];
for (int sub = 0; sub < liveTerms.Length; sub++)
{
AtomicReader reader = readers[sub];
SortedDocValues dv = dvs[sub];
IBits liveDocs = reader.LiveDocs;
if (liveDocs == null)
{
liveTerms[sub] = dv.GetTermsEnum();
}
else
{
var bitset = new Int64BitSet(dv.ValueCount);
for (int i = 0; i < reader.MaxDoc; i++)
{
if (liveDocs.Get(i))
{
int ord = dv.GetOrd(i);
if (ord >= 0)
{
bitset.Set(ord);
}
}
}
liveTerms[sub] = new BitsFilteredTermsEnum(dv.GetTermsEnum(), bitset);
}
}
// step 2: create ordinal map (this conceptually does the "merging")
var map = new OrdinalMap(this, liveTerms);
// step 3: add field
AddSortedField(fieldInfo, GetMergeSortValuesEnumerable(map, dvs),
// doc -> ord
GetMergeSortedFieldDocToOrdEnumerable(readers, dvs, map)
);
}
/// <summary>
/// Returns a <see cref="DocIdSet"/> with documents that should be permitted in search
/// results.
/// </summary>
public override DocIdSet GetDocIdSet(AtomicReaderContext context, IBits acceptDocs)
{
SortedSetDocValues docTermOrds = FieldCache.DEFAULT.GetDocTermOrds((context.AtomicReader), m_query.m_field);
// Cannot use FixedBitSet because we require long index (ord):
Int64BitSet termSet = new Int64BitSet(docTermOrds.ValueCount);
TermsEnum termsEnum = m_query.GetTermsEnum(new TermsAnonymousInnerClassHelper(docTermOrds));
if (Debugging.AssertsEnabled)
{
Debugging.Assert(termsEnum != null);
}
if (termsEnum.MoveNext())
{
// fill into a bitset
do
{
termSet.Set(termsEnum.Ord);
} while (termsEnum.MoveNext());
}
else
{
return(null);
}
return(new FieldCacheDocIdSet(context.Reader.MaxDoc, acceptDocs, (doc) =>
{
docTermOrds.SetDocument(doc);
long ord;
// TODO: we could track max bit set and early terminate (since they come in sorted order)
while ((ord = docTermOrds.NextOrd()) != SortedSetDocValues.NO_MORE_ORDS)
{
if (termSet.Get(ord))
{
return true;
}
}
return false;
}));
}
/// <summary>
/// Returns a DocIdSet with documents that should be permitted in search
/// results.
/// </summary>
public override DocIdSet GetDocIdSet(AtomicReaderContext context, IBits acceptDocs)
{
SortedDocValues fcsi = FieldCache.DEFAULT.GetTermsIndex((context.AtomicReader), m_query.m_field);
// Cannot use FixedBitSet because we require long index (ord):
Int64BitSet termSet = new Int64BitSet(fcsi.ValueCount);
TermsEnum termsEnum = m_query.GetTermsEnum(new TermsAnonymousClass(fcsi));
if (Debugging.AssertsEnabled)
{
Debugging.Assert(termsEnum != null);
}
if (termsEnum.MoveNext())
{
// fill into a bitset
do
{
long ord = termsEnum.Ord;
if (ord >= 0)
{
termSet.Set(ord);
}
} while (termsEnum.MoveNext());
}
else
{
return(null);
}
return(new FieldCacheDocIdSet(context.Reader.MaxDoc, acceptDocs, (doc) =>
{
int ord = fcsi.GetOrd(doc);
if (ord == -1)
{
return false;
}
return termSet.Get(ord);
}));
}
internal BitsFilteredTermsEnum(TermsEnum @in, Int64BitSet liveTerms)
: base(@in, false)
{
Debug.Assert(liveTerms != null);
this.liveTerms = liveTerms;
}
