/// <summary>
/// for each index document for defined Term
/// </summary>
public static void ForEachTermDocs(this IndexWriter writer, Term whereTerm, string[] fields, Action <Document> todo)
{
if (writer == null)
{
throw new ArgumentNullException(nameof(writer));
}
if (whereTerm == null)
{
throw new ArgumentNullException(nameof(whereTerm));
}
if (fields == null)
{
throw new ArgumentNullException(nameof(fields));
}
if (todo == null)
{
throw new ArgumentNullException(nameof(todo));
}
using (var reader = writer.GetReader(true))
{
var docs = MultiFields.GetTermDocsEnum(reader, null, whereTerm.Field, whereTerm.Bytes, DocsFlags.NONE);
if (docs != null)
{
var docId = 0;
while ((docId = docs.NextDoc()) != DocIdSetIterator.NO_MORE_DOCS)
{
var visitor = new DocumentStoredFieldVisitor(fields);
reader.Document(docId, visitor);
todo(visitor.Document);
}
}
}
}
public override int GetOrdinal(FacetLabel cp)
{
EnsureOpen();
if (cp.Length == 0)
{
return(ROOT_ORDINAL);
}
// First try to find the answer in the LRU cache:
// LUCENENET: Lock was removed here because the underlying cache is thread-safe,
// and removing the lock seems to make the performance better.
Int32Class res = ordinalCache.Get(cp);
if (res != null)
{
if ((int)res.Value < indexReader.MaxDoc)
{
// Since the cache is shared with DTR instances allocated from
// doOpenIfChanged, we need to ensure that the ordinal is one that
// this DTR instance recognizes.
return((int)res.Value);
}
else
{
// if we get here, it means that the category was found in the cache,
// but is not recognized by this TR instance. Therefore there's no
// need to continue search for the path on disk, because we won't find
// it there too.
return(TaxonomyReader.INVALID_ORDINAL);
}
}
// If we're still here, we have a cache miss. We need to fetch the
// value from disk, and then also put it in the cache:
int ret = TaxonomyReader.INVALID_ORDINAL;
DocsEnum docs = MultiFields.GetTermDocsEnum(indexReader, null, Consts.FULL, new BytesRef(FacetsConfig.PathToString(cp.Components, cp.Length)), 0);
if (docs != null && docs.NextDoc() != DocIdSetIterator.NO_MORE_DOCS)
{
ret = docs.DocID;
// we only store the fact that a category exists, not its inexistence.
// This is required because the caches are shared with new DTR instances
// that are allocated from doOpenIfChanged. Therefore, if we only store
// information about found categories, we cannot accidently tell a new
// generation of DTR that a category does not exist.
// LUCENENET: Lock was removed here because the underlying cache is thread-safe,
// and removing the lock seems to make the performance better.
ordinalCache.Put(cp, new Int32Class {
Value = Convert.ToInt32(ret)
});
}
return(ret);
}
private FixedBitSet CreateExpectedResult(string queryValue, bool from, IndexReader topLevelReader,
IndexIterationContext context)
{
IDictionary <string, IList <RandomDoc> > randomValueDocs;
IDictionary <string, IList <RandomDoc> > linkValueDocuments;
if (from)
{
randomValueDocs = context.RandomValueFromDocs;
linkValueDocuments = context.ToDocuments;
}
else
{
randomValueDocs = context.RandomValueToDocs;
linkValueDocuments = context.FromDocuments;
}
FixedBitSet expectedResult = new FixedBitSet(topLevelReader.MaxDoc);
if (!randomValueDocs.TryGetValue(queryValue, out IList <RandomDoc> matchingDocs) || matchingDocs == null)
{
return(new FixedBitSet(topLevelReader.MaxDoc));
}
foreach (RandomDoc matchingDoc in matchingDocs)
{
foreach (string linkValue in matchingDoc.linkValues)
{
if (!linkValueDocuments.TryGetValue(linkValue, out IList <RandomDoc> otherMatchingDocs) || otherMatchingDocs == null)
{
continue;
}
foreach (RandomDoc otherSideDoc in otherMatchingDocs)
{
DocsEnum docsEnum = MultiFields.GetTermDocsEnum(topLevelReader,
MultiFields.GetLiveDocs(topLevelReader), "id", new BytesRef(otherSideDoc.id), 0);
if (Debugging.AssertsEnabled)
{
Debugging.Assert(docsEnum != null);
}
int doc = docsEnum.NextDoc();
expectedResult.Set(doc);
}
}
}
return(expectedResult);
}
public override int GetOrdinal(FacetLabel cp)
{
EnsureOpen();
if (cp.Length == 0)
{
return(ROOT_ORDINAL);
}
// First try to find the answer in the LRU cache:
// LUCENENET: Despite LRUHashMap being thread-safe, we get much better performance
// if reads are separated from writes.
ordinalCacheLock.EnterReadLock();
try
{
if (ordinalCache.TryGetValue(cp, out Int32Class res))
{
if (res < indexReader.MaxDoc)
{
// Since the cache is shared with DTR instances allocated from
// doOpenIfChanged, we need to ensure that the ordinal is one that
// this DTR instance recognizes.
return(res);
}
else
{
// if we get here, it means that the category was found in the cache,
// but is not recognized by this TR instance. Therefore there's no
// need to continue search for the path on disk, because we won't find
// it there too.
return(TaxonomyReader.INVALID_ORDINAL);
}
}
}
finally
{
ordinalCacheLock.ExitReadLock();
}
// If we're still here, we have a cache miss. We need to fetch the
// value from disk, and then also put it in the cache:
int ret = TaxonomyReader.INVALID_ORDINAL;
DocsEnum docs = MultiFields.GetTermDocsEnum(indexReader, null, Consts.FULL, new BytesRef(FacetsConfig.PathToString(cp.Components, cp.Length)), 0);
if (docs != null && docs.NextDoc() != DocIdSetIterator.NO_MORE_DOCS)
{
ret = docs.DocID;
// we only store the fact that a category exists, not its inexistence.
// This is required because the caches are shared with new DTR instances
// that are allocated from doOpenIfChanged. Therefore, if we only store
// information about found categories, we cannot accidently tell a new
// generation of DTR that a category does not exist.
ordinalCacheLock.EnterWriteLock();
try
{
ordinalCache[cp] = ret;
}
finally
{
ordinalCacheLock.ExitWriteLock();
}
}
return(ret);
}