| public GetSequentialSubReaders ( ) : Lucene.Net.Index.IndexReader[] | ||
| return | Lucene.Net.Index.IndexReader[] | |
public static IDictionary<string, Filter> CreateFilters(IndexReader reader, IDictionary<string, HashSet<string>> feeds)
{
var bitSetLookup = new Dictionary<string, IDictionary<string, OpenBitSet>>(StringComparer.OrdinalIgnoreCase);
foreach (var key in feeds.Keys)
{
bitSetLookup[key] = new Dictionary<string, OpenBitSet>();
foreach (SegmentReader segmentReader in reader.GetSequentialSubReaders())
{
bitSetLookup[key][segmentReader.SegmentName] = new OpenBitSet();
}
}
foreach (SegmentReader segmentReader in reader.GetSequentialSubReaders())
{
CreateOpenBitSets(segmentReader, feeds, bitSetLookup);
}
var filters = new Dictionary<string, Filter>(StringComparer.OrdinalIgnoreCase);
foreach (var key in feeds.Keys)
{
filters[key] = new OpenBitSetLookupFilter(bitSetLookup[key]);
}
return filters;
}
public void Process(IndexReader indexReader)
{
var perIndexDocumentNumber = 0;
foreach (var handler in _handlers)
{
handler.Begin(indexReader);
}
if (_enumerateSubReaders && indexReader.GetSequentialSubReaders() != null)
{
foreach (SegmentReader segmentReader in indexReader.GetSequentialSubReaders())
{
ProcessReader(segmentReader, segmentReader.SegmentName, ref perIndexDocumentNumber);
}
}
else
{
ProcessReader(indexReader, string.Empty, ref perIndexDocumentNumber);
}
foreach (var handler in _handlers)
{
handler.End(indexReader);
}
}
public static Filter Create(IndexReader indexReader, bool includePrerelease, bool includeUnlisted)
{
IDictionary<string, OpenBitSet> openBitSetLookup = new Dictionary<string, OpenBitSet>();
if (indexReader.GetSequentialSubReaders() != null)
{
foreach (SegmentReader segmentReader in indexReader.GetSequentialSubReaders())
{
openBitSetLookup.Add(segmentReader.SegmentName, new OpenBitSet());
}
}
else
{
openBitSetLookup.Add(string.Empty, new OpenBitSet());
}
IDictionary<string, Tuple<NuGetVersion, string, int>> lookup = MakeLatestVersionLookup(indexReader, includePrerelease, includeUnlisted);
foreach (Tuple<NuGetVersion, string, int> entry in lookup.Values)
{
string readerName = entry.Item2;
int readerDocumentId = entry.Item3;
openBitSetLookup[readerName].Set(readerDocumentId);
}
return new OpenBitSetLookupFilter(openBitSetLookup);
}
public void Begin(IndexReader indexReader)
{
_bitSetLookup = new Dictionary<string, IDictionary<string, OpenBitSet>>(StringComparer.OrdinalIgnoreCase);
if (indexReader.GetSequentialSubReaders() != null)
{
foreach (var key in _feeds.Keys)
{
_bitSetLookup[key] = new Dictionary<string, OpenBitSet>();
foreach (SegmentReader segmentReader in indexReader.GetSequentialSubReaders())
{
_bitSetLookup[key][segmentReader.SegmentName] = new OpenBitSet();
}
}
}
else
{
foreach (var key in _feeds.Keys)
{
_bitSetLookup[key] = new Dictionary<string, OpenBitSet>();
_bitSetLookup[key][string.Empty] = new OpenBitSet();
}
}
}
public void Begin(IndexReader indexReader)
{
if (indexReader.GetSequentialSubReaders() != null)
{
foreach (SegmentReader segmentReader in indexReader.GetSequentialSubReaders())
{
_mapping[segmentReader.SegmentName] = new int[segmentReader.MaxDoc];
}
}
else
{
_mapping[string.Empty] = new int[indexReader.MaxDoc];
}
}
public void Begin(IndexReader indexReader)
{
_rankingBySegmentReaderName = new RankingBySegment();
if (indexReader.GetSequentialSubReaders() != null)
{
foreach (SegmentReader segmentReader in indexReader.GetSequentialSubReaders())
{
_rankingBySegmentReaderName[segmentReader.SegmentName] = new Ranking[segmentReader.MaxDoc];
}
}
else
{
_rankingBySegmentReaderName[string.Empty] = new Ranking[indexReader.MaxDoc];
}
}
// test using a sparse index (with deleted docs). The DocIdSet should be not cacheable, as it uses TermDocs if the range contains 0
public void TestSparseIndex()
{
RAMDirectory dir = new RAMDirectory();
IndexWriter writer = new IndexWriter(dir, new SimpleAnalyzer(), T, IndexWriter.MaxFieldLength.LIMITED, null);
for (int d = -20; d <= 20; d++)
{
Document doc = new Document();
doc.Add(new Field("id", d.ToString(), Field.Store.NO, Field.Index.NOT_ANALYZED));
doc.Add(new Field("body", "body", Field.Store.NO, Field.Index.NOT_ANALYZED));
writer.AddDocument(doc, null);
}
writer.Optimize(null);
writer.DeleteDocuments(null, new Term("id", "0"));
writer.Close();
IndexReader reader = IndexReader.Open((Directory)dir, true, null);
IndexSearcher Search = new IndexSearcher(reader);
Assert.True(reader.HasDeletions);
ScoreDoc[] result;
Query q = new TermQuery(new Term("body", "body"));
FieldCacheRangeFilter <sbyte?> fcrf;
result = Search.Search(q, fcrf = FieldCacheRangeFilter.NewByteRange("id", -20, 20, T, T), 100, null).ScoreDocs;
Assert.False(fcrf.GetDocIdSet(reader.GetSequentialSubReaders()[0], null).IsCacheable, "DocIdSet must be not cacheable");
Assert.AreEqual(40, result.Length, "find all");
result = Search.Search(q, fcrf = FieldCacheRangeFilter.NewByteRange("id", 0, 20, T, T), 100, null).ScoreDocs;
Assert.False(fcrf.GetDocIdSet(reader.GetSequentialSubReaders()[0], null).IsCacheable, "DocIdSet must be not cacheable");
Assert.AreEqual(20, result.Length, "find all");
result = Search.Search(q, fcrf = FieldCacheRangeFilter.NewByteRange("id", -20, 0, T, T), 100, null).ScoreDocs;
Assert.False(fcrf.GetDocIdSet(reader.GetSequentialSubReaders()[0], null).IsCacheable, "DocIdSet must be not cacheable");
Assert.AreEqual(20, result.Length, "find all");
result = Search.Search(q, fcrf = FieldCacheRangeFilter.NewByteRange("id", 10, 20, T, T), 100, null).ScoreDocs;
Assert.True(fcrf.GetDocIdSet(reader.GetSequentialSubReaders()[0], null).IsCacheable, "DocIdSet must be not cacheable");
Assert.AreEqual(11, result.Length, "find all");
result = Search.Search(q, fcrf = FieldCacheRangeFilter.NewByteRange("id", -20, -10, T, T), 100, null).ScoreDocs;
Assert.True(fcrf.GetDocIdSet(reader.GetSequentialSubReaders()[0], null).IsCacheable, "DocIdSet must be not cacheable");
Assert.AreEqual(11, result.Length, "find all");
}
public void Begin(IndexReader indexReader)
{
_openBitSetLookup = new Dictionary<string, OpenBitSet>();
_lookup = new Dictionary<string, Tuple<NuGetVersion, string, int>>();
if (indexReader.GetSequentialSubReaders() != null)
{
foreach (SegmentReader segmentReader in indexReader.GetSequentialSubReaders())
{
_openBitSetLookup.Add(segmentReader.SegmentName, new OpenBitSet());
}
}
else
{
_openBitSetLookup.Add(string.Empty, new OpenBitSet());
}
}
public void Begin(IndexReader indexReader)
{
_knownOwners = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
_ownerTuples = new Dictionary<string, IDictionary<string, DynamicDocIdSet>>();
if (indexReader.GetSequentialSubReaders() != null)
{
foreach (SegmentReader segmentReader in indexReader.GetSequentialSubReaders())
{
_ownerTuples.Add(segmentReader.SegmentName, new Dictionary<string, DynamicDocIdSet>(StringComparer.OrdinalIgnoreCase));
}
}
else
{
_ownerTuples.Add(string.Empty, new Dictionary<string, DynamicDocIdSet>(StringComparer.OrdinalIgnoreCase));
}
}
static IDictionary<string, Tuple<NuGetVersion, string, int>> MakeLatestVersionLookup(IndexReader indexReader, bool includePrerelease, bool includeUnlisted)
{
IDictionary<string, Tuple<NuGetVersion, string, int>> lookup = new Dictionary<string, Tuple<NuGetVersion, string, int>>();
if (indexReader.GetSequentialSubReaders() != null)
{
foreach (SegmentReader segmentReader in indexReader.GetSequentialSubReaders())
{
MakeLatestVersionLookupPerReader(lookup, segmentReader, segmentReader.SegmentName, includePrerelease, includeUnlisted);
}
}
else
{
MakeLatestVersionLookupPerReader(lookup, indexReader, string.Empty, includePrerelease, includeUnlisted);
}
return lookup;
}
static IDictionary<string, Tuple<NuGetVersion, string, int>> MakeLatestVersionLookup(IndexReader indexReader, bool includePrerelease, bool includeUnlisted)
{
IDictionary<string, Tuple<NuGetVersion, string, int>> lookup = new Dictionary<string, Tuple<NuGetVersion, string, int>>();
foreach (SegmentReader segmentReader in indexReader.GetSequentialSubReaders())
{
for (int n = 0; n < segmentReader.MaxDoc; n++)
{
if (segmentReader.IsDeleted(n))
{
continue;
}
Document document = segmentReader.Document(n);
NuGetVersion version = GetVersion(document);
if (version == null)
{
continue;
}
bool isListed = GetListed(document);
if (isListed || includeUnlisted)
{
if (!version.IsPrerelease || includePrerelease)
{
string id = GetId(document);
if (id == null)
{
continue;
}
Tuple<NuGetVersion, string, int> existingVersion;
if (lookup.TryGetValue(id, out existingVersion))
{
if (version > existingVersion.Item1)
{
lookup[id] = Tuple.Create(version, segmentReader.SegmentName, n);
}
}
else
{
lookup.Add(id, Tuple.Create(version, segmentReader.SegmentName, n));
}
}
}
}
}
return lookup;
}
public static IDictionary<string, BitSetsLookupEntry> CreateBitSetsLookup(IndexReader reader, IDictionary<string, ISet<string>> frameworkCompatibility)
{
// This is a two step process because we first need to calculate the highest version across the whole data set (i.e. across every segment)
// STEP 1. Create a lookup table of compatible documents (identified by SegmentName and Doc) per entry in the framework compatibility table
// (The result include separate structures for release-only and including pre-release.)
IDictionary<string, MatchingDocsEntry> matchingDocsLookup = new Dictionary<string, MatchingDocsEntry>();
foreach (string key in frameworkCompatibility.Keys)
{
matchingDocsLookup[key] = new MatchingDocsEntry();
}
foreach (SegmentReader segmentReader in reader.GetSequentialSubReaders())
{
UpdateMatchingDocs(matchingDocsLookup, segmentReader, frameworkCompatibility);
}
// STEP 2. From the globally created MatchingDocsLookup table we create per-segment lookups
IDictionary<string, BitSetsLookupEntry> bitSetsLookup = new Dictionary<string, BitSetsLookupEntry>();
foreach (string key in frameworkCompatibility.Keys)
{
BitSetsLookupEntry newBitSetsLookupEntry = new BitSetsLookupEntry();
foreach (SegmentReader segmentReader in reader.GetSequentialSubReaders())
{
newBitSetsLookupEntry.MatchingDocs.Add(segmentReader.SegmentName, new OpenBitSet());
newBitSetsLookupEntry.MatchingDocsPre.Add(segmentReader.SegmentName, new OpenBitSet());
}
bitSetsLookup[key] = newBitSetsLookupEntry;
}
foreach (KeyValuePair<string, MatchingDocsEntry> entry in matchingDocsLookup)
{
foreach (MatchingDoc matchingDoc in entry.Value.MatchingDocs.Values)
{
bitSetsLookup[entry.Key].MatchingDocs[matchingDoc.SegmentName].Set(matchingDoc.Doc);
}
foreach (MatchingDoc matchingDocPre in entry.Value.MatchingDocsPre.Values)
{
bitSetsLookup[entry.Key].MatchingDocsPre[matchingDocPre.SegmentName].Set(matchingDocPre.Doc);
}
}
return bitSetsLookup;
}
public virtual void TestCloneSubreaders()
{
Directory dir1 = new MockRAMDirectory();
TestIndexReaderReopen.CreateIndex(dir1, true);
IndexReader reader = IndexReader.Open(dir1, false);
reader.DeleteDocument(1); // acquire write lock
IndexReader[] subs = reader.GetSequentialSubReaders();
System.Diagnostics.Debug.Assert(subs.Length > 1);
IndexReader[] clones = new IndexReader[subs.Length];
for (int x = 0; x < subs.Length; x++)
{
clones[x] = (IndexReader)subs[x].Clone();
}
reader.Close();
for (int x = 0; x < subs.Length; x++)
{
clones[x].Close();
}
dir1.Close();
}
public override IndexReader[] GetSequentialSubReaders()
{
return(in_Renamed.GetSequentialSubReaders());
}
public /*internal*/ static SegmentReader GetOnlySegmentReader(IndexReader reader)
{
if (reader is SegmentReader)
return (SegmentReader) reader;
if (reader is DirectoryReader)
{
IndexReader[] subReaders = reader.GetSequentialSubReaders();
if (subReaders.Length != 1)
{
throw new System.ArgumentException(reader + " has " + subReaders.Length + " segments instead of exactly one");
}
return (SegmentReader) subReaders[0];
}
throw new System.ArgumentException(reader + " is not a SegmentReader or a single-segment DirectoryReader");
}
private void AssertReaderClosed(IndexReader reader, bool checkSubReaders, bool checkNormsClosed)
{
Assert.AreEqual(0, reader.GetRefCount());
if (checkNormsClosed && reader is SegmentReader)
{
Assert.IsTrue(((SegmentReader) reader).NormsClosed());
}
if (checkSubReaders)
{
if (reader is DirectoryReader)
{
IndexReader[] subReaders = reader.GetSequentialSubReaders();
for (int i = 0; i < subReaders.Length; i++)
{
AssertReaderClosed(subReaders[i], checkSubReaders, checkNormsClosed);
}
}
if (reader is MultiReader)
{
IndexReader[] subReaders = reader.GetSequentialSubReaders();
for (int i = 0; i < subReaders.Length; i++)
{
AssertReaderClosed(subReaders[i], checkSubReaders, checkNormsClosed);
}
}
if (reader is ParallelReader)
{
IndexReader[] subReaders = ((ParallelReader) reader).GetSubReaders();
for (int i = 0; i < subReaders.Length; i++)
{
AssertReaderClosed(subReaders[i], checkSubReaders, checkNormsClosed);
}
}
}
}