|
public Clone ( bool openReadOnly ) : |
||
| openReadOnly | bool | |
| return | ||
public virtual void TestCloneWithSetNorm()
{
Directory dir1 = new MockRAMDirectory();
TestIndexReaderReopen.CreateIndex(dir1, false);
IndexReader orig = IndexReader.Open(dir1, false);
orig.SetNorm(1, "field1", 17.0f);
byte encoded = Similarity.EncodeNorm(17.0f);
Assert.AreEqual(encoded, orig.Norms("field1")[1]);
// the cloned segmentreader should have 2 references, 1 to itself, and 1 to
// the original segmentreader
IndexReader clonedReader = (IndexReader)orig.Clone();
orig.Close();
clonedReader.Close();
IndexReader r = IndexReader.Open(dir1, false);
Assert.AreEqual(encoded, r.Norms("field1")[1]);
r.Close();
dir1.Close();
}
public virtual void TestFSDirectoryClone()
{
System.String tempDir = System.IO.Path.GetTempPath();
if (tempDir == null)
{
throw new System.IO.IOException("java.io.tmpdir undefined, cannot run test");
}
System.IO.FileInfo indexDir2 = new System.IO.FileInfo(System.IO.Path.Combine(tempDir, "FSDirIndexReaderClone"));
Directory dir1 = FSDirectory.GetDirectory(indexDir2);
TestIndexReaderReopen.CreateIndex(dir1, false);
IndexReader reader = IndexReader.Open(indexDir2);
IndexReader readOnlyReader = (IndexReader)reader.Clone();
reader.Close();
readOnlyReader.Close();
// Make sure we didn't pick up too many incRef's along
// the way -- this close should be the final close:
dir1.Close();
try
{
dir1.ListAll();
Assert.Fail("did not hit AlreadyClosedException");
}
catch (AlreadyClosedException ace)
{
// expected
}
}
/// <summary> 1. Get a norm from the original reader 2. Clone the original reader 3.
/// Delete a document and set the norm of the cloned reader 4. Verify the norms
/// are not the same on each reader 5. Verify the doc deleted is only in the
/// cloned reader 6. Try to delete a document in the original reader, an
/// exception should be thrown
///
/// </summary>
/// <param name="r1">IndexReader to perform tests on
/// </param>
/// <throws> Exception </throws>
private void PerformDefaultTests(IndexReader r1)
{
float norm1 = Similarity.DecodeNorm(r1.Norms("field1")[4]);
IndexReader pr1Clone = (IndexReader)r1.Clone();
pr1Clone.DeleteDocument(10);
pr1Clone.SetNorm(4, "field1", 0.5f);
Assert.IsTrue(Similarity.DecodeNorm(r1.Norms("field1")[4]) == norm1);
Assert.IsTrue(Similarity.DecodeNorm(pr1Clone.Norms("field1")[4]) != norm1);
Assert.IsTrue(!r1.IsDeleted(10));
Assert.IsTrue(pr1Clone.IsDeleted(10));
// try to update the original reader, which should throw an exception
try
{
r1.DeleteDocument(11);
Assert.Fail("Tried to delete doc 11 and an exception should have been thrown");
}
catch (System.Exception exception)
{
// expectted
}
pr1Clone.Close();
}
public virtual void TestCloneWriteableToReadOnly()
{
Directory dir1 = new MockRAMDirectory();
TestIndexReaderReopen.CreateIndex(dir1, true);
IndexReader reader = IndexReader.Open(dir1, false);
IndexReader readOnlyReader = reader.Clone(true);
if (!IsReadOnly(readOnlyReader))
{
Assert.Fail("reader isn't read only");
}
if (DeleteWorked(1, readOnlyReader))
{
Assert.Fail("deleting from the original should not have worked");
}
// this readonly reader shouldn't have a write lock
if (readOnlyReader.hasChanges_ForNUnit)
{
Assert.Fail("readOnlyReader has a write lock");
}
reader.Close();
readOnlyReader.Close();
dir1.Close();
}
public virtual void TestNormsRefCounting()
{
Directory dir1 = new MockRAMDirectory();
TestIndexReaderReopen.CreateIndex(dir1, false);
IndexReader reader1 = IndexReader.Open(dir1, false);
IndexReader reader2C = (IndexReader)reader1.Clone();
SegmentReader segmentReader2C = SegmentReader.GetOnlySegmentReader(reader2C);
segmentReader2C.Norms("field1"); // load the norms for the field
Norm reader2CNorm = segmentReader2C.norms_ForNUnit["field1"];
Assert.IsTrue(reader2CNorm.BytesRef().RefCount() == 2, "reader2CNorm.bytesRef()=" + reader2CNorm.BytesRef());
IndexReader reader3C = (IndexReader)reader2C.Clone();
SegmentReader segmentReader3C = SegmentReader.GetOnlySegmentReader(reader3C);
Norm reader3CCNorm = segmentReader3C.norms_ForNUnit["field1"];
Assert.AreEqual(3, reader3CCNorm.BytesRef().RefCount());
// edit a norm and the refcount should be 1
IndexReader reader4C = (IndexReader)reader3C.Clone();
SegmentReader segmentReader4C = SegmentReader.GetOnlySegmentReader(reader4C);
Assert.AreEqual(4, reader3CCNorm.BytesRef().RefCount());
reader4C.SetNorm(5, "field1", 0.33f);
// generate a cannot update exception in reader1
Assert.Throws <LockObtainFailedException>(() => reader3C.SetNorm(1, "field1", 0.99f), "did not hit expected exception");
// norm values should be different
Assert.IsTrue(Similarity.DecodeNorm(segmentReader3C.Norms("field1")[5]) != Similarity.DecodeNorm(segmentReader4C.Norms("field1")[5]));
Norm reader4CCNorm = segmentReader4C.norms_ForNUnit["field1"];
Assert.AreEqual(3, reader3CCNorm.BytesRef().RefCount());
Assert.AreEqual(1, reader4CCNorm.BytesRef().RefCount());
IndexReader reader5C = (IndexReader)reader4C.Clone();
SegmentReader segmentReader5C = SegmentReader.GetOnlySegmentReader(reader5C);
Norm reader5CCNorm = segmentReader5C.norms_ForNUnit["field1"];
reader5C.SetNorm(5, "field1", 0.7f);
Assert.AreEqual(1, reader5CCNorm.BytesRef().RefCount());
reader5C.Close();
reader4C.Close();
reader3C.Close();
reader2C.Close();
reader1.Close();
dir1.Close();
}
public virtual void TestCloneReadOnlyDirectoryReader()
{
Directory dir1 = new MockRAMDirectory();
TestIndexReaderReopen.CreateIndex(dir1, true);
IndexReader reader = IndexReader.Open(dir1, false);
IndexReader readOnlyReader = reader.Clone(true);
Assert.IsTrue(IsReadOnly(readOnlyReader), "reader isn't read only");
reader.Close();
readOnlyReader.Close();
dir1.Close();
}
public virtual void TestCloneNoChangesStillReadOnly()
{
Directory dir1 = new MockRAMDirectory();
TestIndexReaderReopen.CreateIndex(dir1, true);
IndexReader r1 = IndexReader.Open(dir1, false);
IndexReader r2 = r1.Clone(false);
Assert.IsTrue(DeleteWorked(1, r2), "deleting from the cloned should have worked");
r1.Close();
r2.Close();
dir1.Close();
}
public virtual void TestCloneWriteToOrig()
{
Directory dir1 = new MockRAMDirectory();
TestIndexReaderReopen.CreateIndex(dir1, true);
IndexReader r1 = IndexReader.Open(dir1, false);
IndexReader r2 = r1.Clone(false);
Assert.IsTrue(DeleteWorked(1, r1), "deleting from the original should have worked");
r1.Close();
r2.Close();
dir1.Close();
}
public virtual void TestCloneReadOnlySegmentReader()
{
Directory dir1 = new MockRAMDirectory();
TestIndexReaderReopen.CreateIndex(dir1, false);
IndexReader reader = IndexReader.Open(dir1, false);
IndexReader readOnlyReader = reader.Clone(true);
Assert.IsTrue(IsReadOnly(readOnlyReader), "reader isn't read only");
Assert.IsFalse(DeleteWorked(1, readOnlyReader), "deleting from the original should not have worked");
reader.Close();
readOnlyReader.Close();
dir1.Close();
}
public virtual void TestReadOnlyCloneAfterOptimize()
{
Directory dir1 = new MockRAMDirectory();
TestIndexReaderReopen.CreateIndex(dir1, true);
IndexReader reader1 = IndexReader.Open(dir1, false);
IndexWriter w = new IndexWriter(dir1, new SimpleAnalyzer(), IndexWriter.MaxFieldLength.LIMITED);
w.Optimize();
w.Close();
IndexReader reader2 = reader1.Clone(true);
Assert.IsTrue(IsReadOnly(reader2));
reader1.Close();
reader2.Close();
dir1.Close();
}
public virtual void TestCloseStoredFields()
{
Directory dir = new MockRAMDirectory();
IndexWriter w = new IndexWriter(dir, new SimpleAnalyzer(), IndexWriter.MaxFieldLength.UNLIMITED);
w.UseCompoundFile = false;
Document doc = new Document();
doc.Add(new Field("field", "yes it's stored", Field.Store.YES, Field.Index.ANALYZED));
w.AddDocument(doc);
w.Close();
IndexReader r1 = IndexReader.Open(dir, false);
IndexReader r2 = r1.Clone(false);
r1.Close();
r2.Close();
dir.Close();
}
public virtual void TestCloneWriteableToReadOnly()
{
Directory dir1 = new MockRAMDirectory();
TestIndexReaderReopen.CreateIndex(dir1, true);
IndexReader reader = IndexReader.Open(dir1, false, null);
IndexReader readOnlyReader = reader.Clone(true, null);
Assert.IsTrue(IsReadOnly(readOnlyReader), "reader isn't read only");
Assert.IsFalse(DeleteWorked(1, readOnlyReader), "deleting from the original should not have worked");
// this readonly reader shouldn't have a write lock
Assert.IsFalse(readOnlyReader.hasChanges, "readOnlyReader has a write lock");
reader.Close();
readOnlyReader.Close();
dir1.Close();
}
/// <summary> 1. Get a norm from the original reader 2. Clone the original reader 3.
/// Delete a document and set the norm of the cloned reader 4. Verify the norms
/// are not the same on each reader 5. Verify the doc deleted is only in the
/// cloned reader 6. Try to delete a document in the original reader, an
/// exception should be thrown
///
/// </summary>
/// <param name="r1">IndexReader to perform tests on
/// </param>
/// <throws> Exception </throws>
private void PerformDefaultTests(IndexReader r1)
{
float norm1 = Similarity.DecodeNorm(r1.Norms("field1")[4]);
IndexReader pr1Clone = (IndexReader)r1.Clone();
pr1Clone.DeleteDocument(10);
pr1Clone.SetNorm(4, "field1", 0.5f);
Assert.IsTrue(Similarity.DecodeNorm(r1.Norms("field1")[4]) == norm1);
Assert.IsTrue(Similarity.DecodeNorm(pr1Clone.Norms("field1")[4]) != norm1);
Assert.IsTrue(!r1.IsDeleted(10));
Assert.IsTrue(pr1Clone.IsDeleted(10));
// try to update the original reader, which should throw an exception
Assert.Throws <LockObtainFailedException>(() => r1.DeleteDocument(11),
"Tried to delete doc 11 and an exception should have been thrown");
pr1Clone.Close();
}
public virtual void TestCloneReadOnlyToWriteable()
{
Directory dir1 = new MockRAMDirectory();
TestIndexReaderReopen.CreateIndex(dir1, true);
IndexReader reader1 = IndexReader.Open(dir1, true);
IndexReader reader2 = reader1.Clone(false);
Assert.IsFalse(IsReadOnly(reader2), "reader should not be read only");
Assert.IsFalse(DeleteWorked(1, reader1), "deleting from the original reader should not have worked");
// this readonly reader shouldn't yet have a write lock
Assert.IsFalse(reader2.hasChanges, "cloned reader should not have write lock");
Assert.IsTrue(DeleteWorked(1, reader2), "deleting from the cloned reader should have worked");
reader1.Close();
reader2.Close();
dir1.Close();
}
public virtual void TestCloneWriteToClone()
{
Directory dir1 = new MockRAMDirectory();
TestIndexReaderReopen.CreateIndex(dir1, true);
IndexReader r1 = IndexReader.Open(dir1, false);
IndexReader r2 = r1.Clone(false);
Assert.IsTrue(DeleteWorked(1, r2), "deleting from the original should have worked");
// should fail because reader1 holds the write lock
Assert.IsTrue(!DeleteWorked(1, r1), "first reader should not be able to delete");
r2.Close();
// should fail because we are now stale (reader1
// committed changes)
Assert.IsTrue(!DeleteWorked(1, r1), "first reader should not be able to delete");
r1.Close();
dir1.Close();
}
public virtual void TestLucene1516Bug()
{
Directory dir1 = new MockRAMDirectory();
TestIndexReaderReopen.CreateIndex(dir1, false);
IndexReader r1 = IndexReader.Open(dir1, false);
r1.IncRef();
IndexReader r2 = r1.Clone(false);
r1.DeleteDocument(5);
r1.DecRef();
r1.IncRef();
r2.Close();
r1.DecRef();
r1.Close();
dir1.Close();
}
public virtual void TestCloneWithDeletes()
{
Directory dir1 = new MockRAMDirectory();
TestIndexReaderReopen.CreateIndex(dir1, false);
IndexReader origReader = IndexReader.Open(dir1, false);
origReader.DeleteDocument(1);
IndexReader clonedReader = (IndexReader)origReader.Clone();
origReader.Close();
clonedReader.Close();
IndexReader r = IndexReader.Open(dir1, false);
Assert.IsTrue(r.IsDeleted(1));
r.Close();
dir1.Close();
}
// try cloning and reopening the norms
private void DoTestNorms(Directory dir)
{
AddDocs(dir, 12, true);
IndexReader ir = IndexReader.Open(dir);
VerifyIndex(ir);
ModifyNormsForF1(ir);
IndexReader irc = (IndexReader)ir.Clone(); // IndexReader.open(dir);//ir.clone();
VerifyIndex(irc);
ModifyNormsForF1(irc);
IndexReader irc3 = (IndexReader)irc.Clone();
VerifyIndex(irc3);
ModifyNormsForF1(irc3);
VerifyIndex(irc3);
irc3.Flush();
irc3.Close();
}
/// <summary> 1. Get a norm from the original reader 2. Clone the original reader 3.
/// Delete a document and set the norm of the cloned reader 4. Verify the norms
/// are not the same on each reader 5. Verify the doc deleted is only in the
/// cloned reader 6. Try to delete a document in the original reader, an
/// exception should be thrown
///
/// </summary>
/// <param name="r1">IndexReader to perform tests on
/// </param>
/// <throws> Exception </throws>
private void PerformDefaultTests(IndexReader r1)
{
float norm1 = Similarity.DecodeNorm(r1.Norms("field1")[4]);
IndexReader pr1Clone = (IndexReader) r1.Clone();
pr1Clone.DeleteDocument(10);
pr1Clone.SetNorm(4, "field1", 0.5f);
Assert.IsTrue(Similarity.DecodeNorm(r1.Norms("field1")[4]) == norm1);
Assert.IsTrue(Similarity.DecodeNorm(pr1Clone.Norms("field1")[4]) != norm1);
Assert.IsTrue(!r1.IsDeleted(10));
Assert.IsTrue(pr1Clone.IsDeleted(10));
// try to update the original reader, which should throw an exception
Assert.Throws<LockObtainFailedException>(() => r1.DeleteDocument(11),
"Tried to delete doc 11 and an exception should have been thrown");
pr1Clone.Close();
}
/// <summary> 1. Get a norm from the original reader 2. Clone the original reader 3.
/// Delete a document and set the norm of the cloned reader 4. Verify the norms
/// are not the same on each reader 5. Verify the doc deleted is only in the
/// cloned reader 6. Try to delete a document in the original reader, an
/// exception should be thrown
///
/// </summary>
/// <param name="r1">IndexReader to perform tests on
/// </param>
/// <throws> Exception </throws>
private void PerformDefaultTests(IndexReader r1)
{
float norm1 = Similarity.DecodeNorm(r1.Norms("field1")[4]);
IndexReader pr1Clone = (IndexReader) r1.Clone();
pr1Clone.DeleteDocument(10);
pr1Clone.SetNorm(4, "field1", 0.5f);
Assert.IsTrue(Similarity.DecodeNorm(r1.Norms("field1")[4]) == norm1);
Assert.IsTrue(Similarity.DecodeNorm(pr1Clone.Norms("field1")[4]) != norm1);
Assert.IsTrue(!r1.IsDeleted(10));
Assert.IsTrue(pr1Clone.IsDeleted(10));
// try to update the original reader, which should throw an exception
try
{
r1.DeleteDocument(11);
Assert.Fail("Tried to delete doc 11 and an exception should have been thrown");
}
catch (System.Exception exception)
{
// expectted
}
pr1Clone.Close();
}
private void Initialize(IndexReader[] subReaders, bool closeSubReaders)
{
this.subReaders = (IndexReader[]) subReaders.Clone();
starts = new int[subReaders.Length + 1]; // build starts array
decrefOnClose = new bool[subReaders.Length];
for (int i = 0; i < subReaders.Length; i++)
{
starts[i] = maxDoc;
maxDoc += subReaders[i].MaxDoc(); // compute maxDocs
if (!closeSubReaders)
{
subReaders[i].IncRef();
decrefOnClose[i] = true;
}
else
{
decrefOnClose[i] = false;
}
if (subReaders[i].HasDeletions())
hasDeletions = true;
}
starts[subReaders.Length] = maxDoc;
}
protected internal virtual IndexReader DoReopen(bool doClone)
{
EnsureOpen();
bool reopened = false;
System.Collections.IList newReaders = new System.Collections.ArrayList();
bool success = false;
try
{
for (int i = 0; i < readers.Count; i++)
{
IndexReader oldReader = (IndexReader)readers[i];
IndexReader newReader = null;
if (doClone)
{
newReader = (IndexReader)oldReader.Clone();
}
else
{
newReader = oldReader.Reopen();
}
newReaders.Add(newReader);
// if at least one of the subreaders was updated we remember that
// and return a new ParallelReader
if (newReader != oldReader)
{
reopened = true;
}
}
success = true;
}
finally
{
if (!success && reopened)
{
for (int i = 0; i < newReaders.Count; i++)
{
IndexReader r = (IndexReader)newReaders[i];
if (r != readers[i])
{
try
{
r.Close();
}
catch (System.IO.IOException ignore)
{
// keep going - we want to clean up as much as possible
}
}
}
}
}
if (reopened)
{
System.Collections.IList newDecrefOnClose = new System.Collections.ArrayList();
ParallelReader pr = new ParallelReader();
for (int i = 0; i < readers.Count; i++)
{
IndexReader oldReader = (IndexReader)readers[i];
IndexReader newReader = (IndexReader)newReaders[i];
if (newReader == oldReader)
{
newDecrefOnClose.Add(true);
newReader.IncRef();
}
else
{
// this is a new subreader instance, so on close() we don't
// decRef but close it
newDecrefOnClose.Add(false);
}
pr.Add(newReader, !storedFieldReaders.Contains(oldReader));
}
pr.decrefOnClose = newDecrefOnClose;
pr.incRefReaders = incRefReaders;
return(pr);
}
else
{
// No subreader was refreshed
return(this);
}
}
public virtual void TestSegmentReaderDelDocsReferenceCounting()
{
Directory dir1 = new MockRAMDirectory();
TestIndexReaderReopen.CreateIndex(dir1, false);
IndexReader origReader = IndexReader.Open(dir1, false);
SegmentReader origSegmentReader = SegmentReader.GetOnlySegmentReader(origReader);
// deletedDocsRef should be null because nothing has updated yet
Assert.IsNull(origSegmentReader.deletedDocsRef_ForNUnit);
// we deleted a document, so there is now a deletedDocs bitvector and a
// reference to it
origReader.DeleteDocument(1);
AssertDelDocsRefCountEquals(1, origSegmentReader);
// the cloned segmentreader should have 2 references, 1 to itself, and 1 to
// the original segmentreader
IndexReader clonedReader = (IndexReader)origReader.Clone();
SegmentReader clonedSegmentReader = SegmentReader.GetOnlySegmentReader(clonedReader);
AssertDelDocsRefCountEquals(2, origSegmentReader);
// deleting a document creates a new deletedDocs bitvector, the refs goes to
// 1
clonedReader.DeleteDocument(2);
AssertDelDocsRefCountEquals(1, origSegmentReader);
AssertDelDocsRefCountEquals(1, clonedSegmentReader);
// make sure the deletedocs objects are different (copy
// on write)
Assert.IsTrue(origSegmentReader.deletedDocs_ForNUnit != clonedSegmentReader.deletedDocs_ForNUnit);
AssertDocDeleted(origSegmentReader, clonedSegmentReader, 1);
Assert.IsTrue(!origSegmentReader.IsDeleted(2)); // doc 2 should not be deleted
// in original segmentreader
Assert.IsTrue(clonedSegmentReader.IsDeleted(2)); // doc 2 should be deleted in
// cloned segmentreader
// deleting a doc from the original segmentreader should throw an exception
Assert.Throws <LockObtainFailedException>(() => origReader.DeleteDocument(4), "expected exception");
origReader.Close();
// try closing the original segment reader to see if it affects the
// clonedSegmentReader
clonedReader.DeleteDocument(3);
clonedReader.Flush();
AssertDelDocsRefCountEquals(1, clonedSegmentReader);
// test a reopened reader
IndexReader reopenedReader = clonedReader.Reopen();
IndexReader cloneReader2 = (IndexReader)reopenedReader.Clone();
SegmentReader cloneSegmentReader2 = SegmentReader.GetOnlySegmentReader(cloneReader2);
AssertDelDocsRefCountEquals(2, cloneSegmentReader2);
clonedReader.Close();
reopenedReader.Close();
cloneReader2.Close();
dir1.Close();
}
