/// <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); }