true if the index is optimized; false otherwise
+ */
public boolean isOptimized() {
- return false;
+ ensureOpen();
+ return segmentInfos.size() == 1 && !hasDeletions();
}
public synchronized int numDocs() {
@@ -463,31 +690,185 @@
return new MultiTermPositions(this, subReaders, starts);
}
- protected void commitChanges() throws IOException {
- for (int i = 0; i < subReaders.length; i++)
- subReaders[i].commit();
+ /**
+ * Tries to acquire the WriteLock on this directory. this method is only valid if this IndexReader is directory
+ * owner.
+ *
+ * @throws StaleReaderException if the index has changed since this reader was opened
+ * @throws CorruptIndexException if the index is corrupt
+ * @throws org.apache.lucene.store.LockObtainFailedException
+ * if another writer has this index open (write.lock could not be
+ * obtained)
+ * @throws IOException if there is a low-level IO error
+ */
+ protected void acquireWriteLock() throws StaleReaderException, CorruptIndexException, LockObtainFailedException, IOException {
+
+ if (readOnly) {
+ // NOTE: we should not reach this code w/ the core
+ // IndexReader classes; however, an external subclass
+ // of IndexReader could reach this.
+ ReadOnlySegmentReader.noWrite();
+ }
+
+ if (segmentInfos != null) {
+ ensureOpen();
+ if (stale)
+ throw new StaleReaderException("IndexReader out of date and no longer valid for delete, undelete, or setNorm operations");
+
+ if (writeLock == null) {
+ Lock writeLock = directory.makeLock(IndexWriter.WRITE_LOCK_NAME);
+ if (!writeLock.obtain(IndexWriter.WRITE_LOCK_TIMEOUT)) // obtain write lock
+ throw new LockObtainFailedException("Index locked for write: " + writeLock);
+ this.writeLock = writeLock;
+
+ // we have to check whether index has changed since this reader was opened.
+ // if so, this reader is no longer valid for deletion
+ if (SegmentInfos.readCurrentVersion(directory) > segmentInfos.getVersion()) {
+ stale = true;
+ this.writeLock.release();
+ this.writeLock = null;
+ throw new StaleReaderException("IndexReader out of date and no longer valid for delete, undelete, or setNorm operations");
+ }
+ }
+ }
+ }
+
+ /** @deprecated */
+ protected void doCommit() throws IOException {
+ doCommit(null);
+ }
+
+ /**
+ * Commit changes resulting from delete, undeleteAll, or setNorm operations
+ *
+ * If an exception is hit, then either no changes or all changes will have been committed to the index (transactional
+ * semantics).
+ *
+ * @throws IOException if there is a low-level IO error
+ */
+ protected void doCommit(Map commitUserData) throws IOException {
+ if (hasChanges) {
+ segmentInfos.setUserData(commitUserData);
+ // Default deleter (for backwards compatibility) is
+ // KeepOnlyLastCommitDeleter:
+ IndexFileDeleter deleter = new IndexFileDeleter(directory,
+ deletionPolicy == null ? new KeepOnlyLastCommitDeletionPolicy() : deletionPolicy,
+ segmentInfos, null, null);
+
+ // Checkpoint the state we are about to change, in
+ // case we have to roll back:
+ startCommit();
+
+ boolean success = false;
+ try {
+ for (int i = 0; i < subReaders.length; i++)
+ subReaders[i].commit();
+
+ // Sync all files we just wrote
+ Iterator it = segmentInfos.files(directory, false).iterator();
+ while (it.hasNext()) {
+ final String fileName = (String) it.next();
+ if (!synced.contains(fileName)) {
+ assert directory.fileExists(fileName);
+ directory.sync(fileName);
+ synced.add(fileName);
+ }
+ }
+
+ segmentInfos.commit(directory);
+ success = true;
+ } finally {
+
+ if (!success) {
+
+ // Rollback changes that were made to
+ // SegmentInfos but failed to get [fully]
+ // committed. This way this reader instance
+ // remains consistent (matched to what's
+ // actually in the index):
+ rollbackCommit();
+
+ // Recompute deletable files & remove them (so
+ // partially written .del files, etc, are
+ // removed):
+ deleter.refresh();
+ }
+ }
+
+ // Have the deleter remove any now unreferenced
+ // files due to this commit:
+ deleter.checkpoint(segmentInfos, true);
+ deleter.close();
+
+ if (writeLock != null) {
+ writeLock.release(); // release write lock
+ writeLock = null;
+ }
+ }
+ hasChanges = false;
}
void startCommit() {
- super.startCommit();
+ rollbackHasChanges = hasChanges;
+ rollbackSegmentInfos = (SegmentInfos) segmentInfos.clone();
for (int i = 0; i < subReaders.length; i++) {
subReaders[i].startCommit();
}
}
void rollbackCommit() {
- super.rollbackCommit();
+ hasChanges = rollbackHasChanges;
+ for (int i = 0; i < segmentInfos.size(); i++) {
+ // Rollback each segmentInfo. Because the
+ // SegmentReader holds a reference to the
+ // SegmentInfo we can't [easily] just replace
+ // segmentInfos, so we reset it in place instead:
+ segmentInfos.info(i).reset(rollbackSegmentInfos.info(i));
+ }
+ rollbackSegmentInfos = null;
for (int i = 0; i < subReaders.length; i++) {
subReaders[i].rollbackCommit();
}
}
+ /** Release the write lock, if needed. */
+ protected void finalize() throws Throwable {
+ try {
+ if (writeLock != null) {
+ writeLock.release(); // release write lock
+ writeLock = null;
+ }
+ } finally {
+ super.finalize();
+ }
+ }
+
+ public Map getCommitUserData() {
+ ensureOpen();
+ return segmentInfos.getUserData();
+ }
+
+ /**
+ * Check whether this IndexReader is still using the current (i.e., most recently committed) version of the index. If
+ * a writer has committed any changes to the index since this reader was opened, this will return false,
+ * in which case you must open a new IndexReader in order to see the changes. See the description of the autoCommit flag which controls when the {@link IndexWriter}
+ * actually commits changes to the index.
+ *
+ * @throws CorruptIndexException if the index is corrupt
+ * @throws IOException if there is a low-level IO error
+ */
+ public boolean isCurrent() throws CorruptIndexException, IOException {
+ ensureOpen();
+ return SegmentInfos.readCurrentVersion(directory) == segmentInfos.getVersion();
+ }
+
protected synchronized void doClose() throws IOException {
for (int i = 0; i < subReaders.length; i++)
subReaders[i].decRef();
-
- // maybe close directory
- super.doClose();
+
+ if (closeDirectory)
+ directory.close();
}
public Collection getFieldNames (IndexReader.FieldOption fieldNames) {
@@ -528,6 +909,119 @@
subReaders[i].setDisableFakeNorms(disableFakeNorms);
}
+ /** Returns the directory this index resides in. */
+ public Directory directory() {
+ // Don't ensureOpen here -- in certain cases, when a
+ // cloned/reopened reader needs to commit, it may call
+ // this method on the closed original reader
+ return directory;
+ }
+
+ /**
+ * Expert: return the IndexCommit that this reader has opened.
+ *
+ * WARNING: this API is new and experimental and may suddenly change.
+ */
+ public IndexCommit getIndexCommit() throws IOException {
+ return new ReaderCommit(segmentInfos, directory);
+ }
+
+ /** @see org.apache.lucene.index.IndexReader#listCommits */
+ public static Collection listCommits(Directory dir) throws IOException {
+ final String[] files = dir.listAll();
+
+ Collection commits = new ArrayList();
+
+ SegmentInfos latest = new SegmentInfos();
+ latest.read(dir);
+ final long currentGen = latest.getGeneration();
+
+ commits.add(new ReaderCommit(latest, dir));
+
+ for(int i=0;i reader2
- IndexReader r2 = (IndexReader) r.reopen();
+ IndexReader r2 = r.reopen();
r.close();
- assertTrue(r2 instanceof MultiSegmentReader);
IndexReader sub0 = r2.getSequentialSubReaders()[0];
- assertTrue(sub0 instanceof SegmentReader);
final int[] ints2 = FieldCache.DEFAULT.getInts(sub0, "number");
r2.close();
assertTrue(ints == ints2);
@@ -1743,14 +1739,15 @@
// Open reader1
IndexReader r = IndexReader.open(dir);
- assertTrue(r instanceof SegmentReader);
- final int[] ints = FieldCache.DEFAULT.getInts(r, "number");
+ assertTrue(r instanceof MultiSegmentReader);
+ IndexReader r1 = SegmentReader.getOnlySegmentReader(r);
+ final int[] ints = FieldCache.DEFAULT.getInts(r1, "number");
assertEquals(1, ints.length);
assertEquals(17, ints[0]);
// Reopen to readonly w/ no chnages
- IndexReader r3 = (IndexReader) r.reopen(true);
- assertTrue(r3 instanceof ReadOnlySegmentReader);
+ IndexReader r3 = r.reopen(true);
+ assertTrue(r3 instanceof ReadOnlyMultiSegmentReader);
r3.close();
// Add new segment
@@ -1758,9 +1755,9 @@
writer.commit();
// Reopen reader1 --> reader2
- IndexReader r2 = (IndexReader) r.reopen(true);
+ IndexReader r2 = r.reopen(true);
r.close();
- assertTrue(r2 instanceof MultiSegmentReader);
+ assertTrue(r2 instanceof ReadOnlyMultiSegmentReader);
IndexReader[] subs = r2.getSequentialSubReaders();
final int[] ints2 = FieldCache.DEFAULT.getInts(subs[0], "number");
r2.close();
@@ -1784,7 +1781,8 @@
writer.commit();
IndexReader r = IndexReader.open(dir);
- assertEquals(36, r.getUniqueTermCount());
+ IndexReader r1 = SegmentReader.getOnlySegmentReader(r);
+ assertEquals(36, r1.getUniqueTermCount());
writer.addDocument(doc);
writer.commit();
IndexReader r2 = r.reopen();
diff --git a/src/test/org/apache/lucene/index/TestIndexReaderClone.java b/src/test/org/apache/lucene/index/TestIndexReaderClone.java
--- a/src/test/org/apache/lucene/index/TestIndexReaderClone.java
+++ b/src/test/org/apache/lucene/index/TestIndexReaderClone.java
@@ -39,7 +39,7 @@
TestIndexReaderReopen.createIndex(dir1, false);
IndexReader reader = IndexReader.open(dir1);
- IndexReader readOnlyReader = (IndexReader) reader.clone(true);
+ IndexReader readOnlyReader = reader.clone(true);
if (!isReadOnly(readOnlyReader)) {
fail("reader isn't read only");
}
@@ -58,7 +58,7 @@
TestIndexReaderReopen.createIndex(dir1, true);
IndexReader r1 = IndexReader.open(dir1, false);
- DirectoryIndexReader r2 = (DirectoryIndexReader) r1.clone(false);
+ IndexReader r2 = r1.clone(false);
if (!deleteWorked(1, r2)) {
fail("deleting from the cloned should have worked");
}
@@ -74,7 +74,7 @@
TestIndexReaderReopen.createIndex(dir1, true);
IndexReader r1 = IndexReader.open(dir1, false);
- DirectoryIndexReader r2 = (DirectoryIndexReader) r1.clone(false);
+ IndexReader r2 = r1.clone(false);
if (!deleteWorked(1, r1)) {
fail("deleting from the original should have worked");
}
@@ -90,7 +90,7 @@
TestIndexReaderReopen.createIndex(dir1, true);
IndexReader r1 = IndexReader.open(dir1, false);
- DirectoryIndexReader r2 = (DirectoryIndexReader) r1.clone(false);
+ IndexReader r2 = r1.clone(false);
if (!deleteWorked(1, r2)) {
fail("deleting from the original should have worked");
}
@@ -131,7 +131,7 @@
TestIndexReaderReopen.createIndex(dir1, true);
IndexReader reader = IndexReader.open(dir1, false);
- DirectoryIndexReader readOnlyReader = (DirectoryIndexReader) reader.clone(true);
+ IndexReader readOnlyReader = reader.clone(true);
if (!isReadOnly(readOnlyReader)) {
fail("reader isn't read only");
}
@@ -157,7 +157,7 @@
assertTrue(deleteWorked(1, reader));
assertEquals(docCount-1, reader.numDocs());
- DirectoryIndexReader readOnlyReader = (DirectoryIndexReader) reader.reopen(true);
+ IndexReader readOnlyReader = reader.reopen(true);
if (!isReadOnly(readOnlyReader)) {
fail("reader isn't read only");
}
@@ -175,7 +175,7 @@
TestIndexReaderReopen.createIndex(dir1, true);
IndexReader reader1 = IndexReader.open(dir1, true);
- DirectoryIndexReader reader2 = (DirectoryIndexReader) reader1.clone(false);
+ IndexReader reader2 = reader1.clone(false);
if (isReadOnly(reader2)) {
fail("reader should not be read only");
}
@@ -223,7 +223,7 @@
TestIndexReaderReopen.createIndex(dir1, true);
IndexReader reader = IndexReader.open(dir1);
- IndexReader readOnlyReader = (IndexReader) reader.clone(true);
+ IndexReader readOnlyReader = reader.clone(true);
if (!isReadOnly(readOnlyReader)) {
fail("reader isn't read only");
}
@@ -307,7 +307,7 @@
public void testSegmentReaderUndeleteall() throws Exception {
final Directory dir1 = new MockRAMDirectory();
TestIndexReaderReopen.createIndex(dir1, false);
- SegmentReader origSegmentReader = (SegmentReader) IndexReader.open(dir1);
+ SegmentReader origSegmentReader = SegmentReader.getOnlySegmentReader(dir1);
origSegmentReader.deleteDocument(10);
assertDelDocsRefCountEquals(1, origSegmentReader);
origSegmentReader.undeleteAll();
@@ -320,7 +320,7 @@
public void testSegmentReaderCloseReferencing() throws Exception {
final Directory dir1 = new MockRAMDirectory();
TestIndexReaderReopen.createIndex(dir1, false);
- SegmentReader origSegmentReader = (SegmentReader) IndexReader.open(dir1);
+ SegmentReader origSegmentReader = SegmentReader.getOnlySegmentReader(dir1);
origSegmentReader.deleteDocument(1);
origSegmentReader.setNorm(4, "field1", 0.5f);
@@ -339,23 +339,25 @@
public void testSegmentReaderDelDocsReferenceCounting() throws Exception {
final Directory dir1 = new MockRAMDirectory();
TestIndexReaderReopen.createIndex(dir1, false);
- SegmentReader origSegmentReader = (SegmentReader) IndexReader.open(dir1);
+
+ IndexReader origReader = IndexReader.open(dir1);
+ SegmentReader origSegmentReader = SegmentReader.getOnlySegmentReader(origReader);
// deletedDocsRef should be null because nothing has updated yet
assertNull(origSegmentReader.deletedDocsRef);
// we deleted a document, so there is now a deletedDocs bitvector and a
// reference to it
- origSegmentReader.deleteDocument(1);
+ origReader.deleteDocument(1);
assertDelDocsRefCountEquals(1, origSegmentReader);
// the cloned segmentreader should have 2 references, 1 to itself, and 1 to
// the original segmentreader
- SegmentReader clonedSegmentReader = (SegmentReader) origSegmentReader
- .clone();
+ 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
- clonedSegmentReader.deleteDocument(2);
+ clonedReader.deleteDocument(2);
assertDelDocsRefCountEquals(1, origSegmentReader);
assertDelDocsRefCountEquals(1, clonedSegmentReader);
@@ -371,28 +373,27 @@
// deleting a doc from the original segmentreader should throw an exception
try {
- origSegmentReader.deleteDocument(4);
+ origReader.deleteDocument(4);
fail("expected exception");
} catch (LockObtainFailedException lbfe) {
// expected
}
- origSegmentReader.close();
+ origReader.close();
// try closing the original segment reader to see if it affects the
// clonedSegmentReader
- clonedSegmentReader.deleteDocument(3);
- clonedSegmentReader.flush();
+ clonedReader.deleteDocument(3);
+ clonedReader.flush();
assertDelDocsRefCountEquals(1, clonedSegmentReader);
// test a reopened reader
- SegmentReader reopenedSegmentReader = (SegmentReader) clonedSegmentReader
- .reopen();
- SegmentReader cloneSegmentReader2 = (SegmentReader) reopenedSegmentReader
- .clone();
+ IndexReader reopenedReader = clonedReader.reopen();
+ IndexReader cloneReader2 = (IndexReader) reopenedReader.clone();
+ SegmentReader cloneSegmentReader2 = SegmentReader.getOnlySegmentReader(cloneReader2);
assertDelDocsRefCountEquals(2, cloneSegmentReader2);
- clonedSegmentReader.close();
- reopenedSegmentReader.close();
- cloneSegmentReader2.close();
+ clonedReader.close();
+ reopenedReader.close();
+ cloneReader2.close();
dir1.close();
}
@@ -401,14 +402,14 @@
public void testCloneWithDeletes() throws Throwable {
final Directory dir1 = new MockRAMDirectory();
TestIndexReaderReopen.createIndex(dir1, false);
- SegmentReader origSegmentReader = (SegmentReader) IndexReader.open(dir1);
- origSegmentReader.deleteDocument(1);
+ IndexReader origReader = IndexReader.open(dir1);
+ origReader.deleteDocument(1);
- SegmentReader clonedSegmentReader = (SegmentReader) origSegmentReader.clone();
- origSegmentReader.close();
- clonedSegmentReader.close();
+ IndexReader clonedReader = (IndexReader) origReader.clone();
+ origReader.close();
+ clonedReader.close();
- SegmentReader r = (SegmentReader) IndexReader.open(dir1);
+ IndexReader r = IndexReader.open(dir1);
assertTrue(r.isDeleted(1));
r.close();
dir1.close();
@@ -418,18 +419,18 @@
public void testCloneWithSetNorm() throws Throwable {
final Directory dir1 = new MockRAMDirectory();
TestIndexReaderReopen.createIndex(dir1, false);
- SegmentReader orig = (SegmentReader) IndexReader.open(dir1);
+ IndexReader orig = IndexReader.open(dir1);
orig.setNorm(1, "field1", 17.0f);
final byte encoded = Similarity.encodeNorm(17.0f);
assertEquals(encoded, orig.norms("field1")[1]);
// the cloned segmentreader should have 2 references, 1 to itself, and 1 to
// the original segmentreader
- SegmentReader clonedSegmentReader = (SegmentReader) orig.clone();
+ IndexReader clonedReader = (IndexReader) orig.clone();
orig.close();
- clonedSegmentReader.close();
+ clonedReader.close();
- SegmentReader r = (SegmentReader) IndexReader.open(dir1);
+ IndexReader r = IndexReader.open(dir1);
assertEquals(encoded, r.norms("field1")[1]);
r.close();
dir1.close();
@@ -469,7 +470,7 @@
TestIndexReaderReopen.createIndex(dir1, false);
IndexReader r1 = IndexReader.open(dir1);
r1.incRef();
- IndexReader r2 = (IndexReader) r1.clone(false);
+ IndexReader r2 = r1.clone(false);
r1.deleteDocument(5);
r1.decRef();
@@ -490,7 +491,7 @@
w.addDocument(doc);
w.close();
IndexReader r1 = IndexReader.open(dir);
- IndexReader r2 = (IndexReader) r1.clone(false);
+ IndexReader r2 = r1.clone(false);
r1.close();
r2.close();
dir.close();
diff --git a/src/test/org/apache/lucene/index/TestIndexReaderCloneNorms.java b/src/test/org/apache/lucene/index/TestIndexReaderCloneNorms.java
--- a/src/test/org/apache/lucene/index/TestIndexReaderCloneNorms.java
+++ b/src/test/org/apache/lucene/index/TestIndexReaderCloneNorms.java
@@ -167,7 +167,7 @@
public void testNormsClose() throws IOException {
Directory dir1 = new MockRAMDirectory();
TestIndexReaderReopen.createIndex(dir1, false);
- SegmentReader reader1 = (SegmentReader) IndexReader.open(dir1);
+ SegmentReader reader1 = SegmentReader.getOnlySegmentReader(dir1);
reader1.norms("field1");
Norm r1norm = (Norm)reader1.norms.get("field1");
SegmentReader.Ref r1BytesRef = r1norm.bytesRef();
@@ -183,21 +183,24 @@
public void testNormsRefCounting() throws IOException {
Directory dir1 = new MockRAMDirectory();
TestIndexReaderReopen.createIndex(dir1, false);
- SegmentReader reader1 = (SegmentReader) IndexReader.open(dir1);
+ IndexReader reader1 = IndexReader.open(dir1);
- SegmentReader reader2C = (SegmentReader)reader1.clone();
- reader2C.norms("field1"); // load the norms for the field
- Norm reader2CNorm = (Norm)reader2C.norms.get("field1");
+ IndexReader reader2C = (IndexReader) reader1.clone();
+ SegmentReader segmentReader2C = SegmentReader.getOnlySegmentReader(reader2C);
+ segmentReader2C.norms("field1"); // load the norms for the field
+ Norm reader2CNorm = (Norm)segmentReader2C.norms.get("field1");
assertTrue("reader2CNorm.bytesRef()=" + reader2CNorm.bytesRef(), reader2CNorm.bytesRef().refCount() == 2);
- SegmentReader reader3C = (SegmentReader)reader2C.clone();
- Norm reader3CCNorm = (Norm)reader3C.norms.get("field1");
+ IndexReader reader3C = (IndexReader) reader2C.clone();
+ SegmentReader segmentReader3C = SegmentReader.getOnlySegmentReader(reader3C);
+ Norm reader3CCNorm = (Norm)segmentReader3C.norms.get("field1");
assertEquals(3, reader3CCNorm.bytesRef().refCount());
// edit a norm and the refcount should be 1
- SegmentReader reader4C = (SegmentReader)reader3C.clone();
+ IndexReader reader4C = (IndexReader) reader3C.clone();
+ SegmentReader segmentReader4C = SegmentReader.getOnlySegmentReader(reader4C);
assertEquals(4, reader3CCNorm.bytesRef().refCount());
reader4C.setNorm(5, "field1", 0.33f);
@@ -210,13 +213,14 @@
}
// norm values should be different
- assertTrue(Similarity.decodeNorm(reader3C.norms("field1")[5]) != Similarity.decodeNorm(reader4C.norms("field1")[5]));
- Norm reader4CCNorm = (Norm)reader4C.norms.get("field1");
+ assertTrue(Similarity.decodeNorm(segmentReader3C.norms("field1")[5]) != Similarity.decodeNorm(segmentReader4C.norms("field1")[5]));
+ Norm reader4CCNorm = (Norm)segmentReader4C.norms.get("field1");
assertEquals(3, reader3CCNorm.bytesRef().refCount());
assertEquals(1, reader4CCNorm.bytesRef().refCount());
- SegmentReader reader5C = (SegmentReader)reader4C.clone();
- Norm reader5CCNorm = (Norm)reader5C.norms.get("field1");
+ IndexReader reader5C = (IndexReader) reader4C.clone();
+ SegmentReader segmentReader5C = SegmentReader.getOnlySegmentReader(reader5C);
+ Norm reader5CCNorm = (Norm)segmentReader5C.norms.get("field1");
reader5C.setNorm(5, "field1", 0.7f);
assertEquals(1, reader5CCNorm.bytesRef().refCount());
diff --git a/src/test/org/apache/lucene/index/TestIndexReaderReopen.java b/src/test/org/apache/lucene/index/TestIndexReaderReopen.java
--- a/src/test/org/apache/lucene/index/TestIndexReaderReopen.java
+++ b/src/test/org/apache/lucene/index/TestIndexReaderReopen.java
@@ -596,66 +596,68 @@
Directory dir1 = new MockRAMDirectory();
createIndex(dir1, false);
- SegmentReader reader1 = (SegmentReader) IndexReader.open(dir1);
+ IndexReader reader1 = IndexReader.open(dir1);
+ SegmentReader segmentReader1 = SegmentReader.getOnlySegmentReader(reader1);
IndexReader modifier = IndexReader.open(dir1);
modifier.deleteDocument(0);
modifier.close();
- SegmentReader reader2 = (SegmentReader) reader1.reopen();
+ IndexReader reader2 = reader1.reopen();
modifier = IndexReader.open(dir1);
modifier.setNorm(1, "field1", 50);
modifier.setNorm(1, "field2", 50);
modifier.close();
- SegmentReader reader3 = (SegmentReader) reader2.reopen();
+ IndexReader reader3 = reader2.reopen();
+ SegmentReader segmentReader3 = SegmentReader.getOnlySegmentReader(reader3);
modifier = IndexReader.open(dir1);
modifier.deleteDocument(2);
modifier.close();
- SegmentReader reader4 = (SegmentReader) reader3.reopen();
+ IndexReader reader4 = reader3.reopen();
modifier = IndexReader.open(dir1);
modifier.deleteDocument(3);
modifier.close();
- SegmentReader reader5 = (SegmentReader) reader3.reopen();
+ IndexReader reader5 = reader3.reopen();
// Now reader2-reader5 references reader1. reader1 and reader2
// share the same norms. reader3, reader4, reader5 also share norms.
assertRefCountEquals(1, reader1);
- assertFalse(reader1.normsClosed());
+ assertFalse(segmentReader1.normsClosed());
reader1.close();
assertRefCountEquals(0, reader1);
- assertFalse(reader1.normsClosed());
+ assertFalse(segmentReader1.normsClosed());
reader2.close();
assertRefCountEquals(0, reader1);
// now the norms for field1 and field2 should be closed
- assertTrue(reader1.normsClosed("field1"));
- assertTrue(reader1.normsClosed("field2"));
+ assertTrue(segmentReader1.normsClosed("field1"));
+ assertTrue(segmentReader1.normsClosed("field2"));
// but the norms for field3 and field4 should still be open
- assertFalse(reader1.normsClosed("field3"));
- assertFalse(reader1.normsClosed("field4"));
+ assertFalse(segmentReader1.normsClosed("field3"));
+ assertFalse(segmentReader1.normsClosed("field4"));
reader3.close();
assertRefCountEquals(0, reader1);
- assertFalse(reader3.normsClosed());
+ assertFalse(segmentReader3.normsClosed());
reader5.close();
assertRefCountEquals(0, reader1);
- assertFalse(reader3.normsClosed());
+ assertFalse(segmentReader3.normsClosed());
reader4.close();
assertRefCountEquals(0, reader1);
// and now all norms that reader1 used should be closed
- assertTrue(reader1.normsClosed());
+ assertTrue(segmentReader1.normsClosed());
// now that reader3, reader4 and reader5 are closed,
// the norms that those three readers shared should be
// closed as well
- assertTrue(reader3.normsClosed());
+ assertTrue(segmentReader3.normsClosed());
dir1.close();
}
@@ -941,12 +943,12 @@
}
w.close();
-
+
IndexReader r = IndexReader.open(dir);
if (multiSegment) {
- assertTrue(r instanceof MultiSegmentReader);
+ assertTrue(r.getSequentialSubReaders().length > 1);
} else {
- assertTrue(r instanceof SegmentReader);
+ assertTrue(r.getSequentialSubReaders().length == 1);
}
r.close();
}
@@ -1208,7 +1210,7 @@
IndexReader[] rs2 = r2.getSequentialSubReaders();
- SegmentReader sr1 = (SegmentReader) r1;
+ SegmentReader sr1 = SegmentReader.getOnlySegmentReader(r1);
SegmentReader sr2 = (SegmentReader) rs2[0];
// At this point they share the same BitVector
diff --git a/src/test/org/apache/lucene/index/TestIndexWriterReader.java b/src/test/org/apache/lucene/index/TestIndexWriterReader.java
--- a/src/test/org/apache/lucene/index/TestIndexWriterReader.java
+++ b/src/test/org/apache/lucene/index/TestIndexWriterReader.java
@@ -461,15 +461,15 @@
IndexWriter writer = new IndexWriter(dir1, new WhitespaceAnalyzer(),
IndexWriter.MaxFieldLength.LIMITED);
writer.setInfoStream(infoStream);
- DirectoryIndexReader r1 = (DirectoryIndexReader) writer.getReader();
+ IndexReader r1 = writer.getReader();
assertEquals(0, r1.maxDoc());
createIndexNoClose(false, "index1", writer);
writer.flush(!optimize, true, true);
- DirectoryIndexReader iwr1 = (DirectoryIndexReader) writer.getReader();
+ IndexReader iwr1 = writer.getReader();
assertEquals(100, iwr1.maxDoc());
- DirectoryIndexReader r2 = (DirectoryIndexReader) writer.getReader();
+ IndexReader r2 = writer.getReader();
assertEquals(r2.maxDoc(), 100);
// add 100 documents
for (int x = 10000; x < 10000 + 100; x++) {
diff --git a/src/test/org/apache/lucene/index/TestLazyProxSkipping.java b/src/test/org/apache/lucene/index/TestLazyProxSkipping.java
--- a/src/test/org/apache/lucene/index/TestLazyProxSkipping.java
+++ b/src/test/org/apache/lucene/index/TestLazyProxSkipping.java
@@ -72,8 +72,7 @@
writer.optimize();
writer.close();
- // the index is a single segment, thus IndexReader.open() returns an instance of SegmentReader
- SegmentReader reader = (SegmentReader) IndexReader.open(directory);
+ SegmentReader reader = SegmentReader.getOnlySegmentReader(directory);
// we decorate the proxStream with a wrapper class that allows to count the number of calls of seek()
reader.proxStream = new SeeksCountingStream(reader.proxStream);
diff --git a/src/test/org/apache/lucene/index/TestMultiLevelSkipList.java b/src/test/org/apache/lucene/index/TestMultiLevelSkipList.java
--- a/src/test/org/apache/lucene/index/TestMultiLevelSkipList.java
+++ b/src/test/org/apache/lucene/index/TestMultiLevelSkipList.java
@@ -56,7 +56,7 @@
writer.optimize();
writer.close();
- IndexReader reader = IndexReader.open(dir);
+ IndexReader reader = SegmentReader.getOnlySegmentReader(dir);
SegmentTermPositions tp = (SegmentTermPositions) reader.termPositions();
tp.freqStream = new CountingStream(tp.freqStream);
diff --git a/src/test/org/apache/lucene/index/TestOmitTf.java b/src/test/org/apache/lucene/index/TestOmitTf.java
--- a/src/test/org/apache/lucene/index/TestOmitTf.java
+++ b/src/test/org/apache/lucene/index/TestOmitTf.java
@@ -90,8 +90,7 @@
writer.close();
_TestUtil.checkIndex(ram);
- // only one segment in the index, so we can cast to SegmentReader
- SegmentReader reader = (SegmentReader) IndexReader.open(ram);
+ SegmentReader reader = SegmentReader.getOnlySegmentReader(ram);
FieldInfos fi = reader.fieldInfos();
assertTrue("OmitTermFreqAndPositions field bit should be set.", fi.fieldInfo("f1").omitTermFreqAndPositions);
assertTrue("OmitTermFreqAndPositions field bit should be set.", fi.fieldInfo("f2").omitTermFreqAndPositions);
@@ -143,8 +142,7 @@
_TestUtil.checkIndex(ram);
- // only one segment in the index, so we can cast to SegmentReader
- SegmentReader reader = (SegmentReader) IndexReader.open(ram);
+ SegmentReader reader = SegmentReader.getOnlySegmentReader(ram);
FieldInfos fi = reader.fieldInfos();
assertTrue("OmitTermFreqAndPositions field bit should be set.", fi.fieldInfo("f1").omitTermFreqAndPositions);
assertTrue("OmitTermFreqAndPositions field bit should be set.", fi.fieldInfo("f2").omitTermFreqAndPositions);
@@ -188,8 +186,7 @@
_TestUtil.checkIndex(ram);
- // only one segment in the index, so we can cast to SegmentReader
- SegmentReader reader = (SegmentReader) IndexReader.open(ram);
+ SegmentReader reader = SegmentReader.getOnlySegmentReader(ram);
FieldInfos fi = reader.fieldInfos();
assertTrue("OmitTermFreqAndPositions field bit should not be set.", !fi.fieldInfo("f1").omitTermFreqAndPositions);
assertTrue("OmitTermFreqAndPositions field bit should be set.", fi.fieldInfo("f2").omitTermFreqAndPositions);
diff --git a/src/test/org/apache/lucene/index/TestPayloads.java b/src/test/org/apache/lucene/index/TestPayloads.java
--- a/src/test/org/apache/lucene/index/TestPayloads.java
+++ b/src/test/org/apache/lucene/index/TestPayloads.java
@@ -117,8 +117,7 @@
// flush
writer.close();
- // only one segment in the index, so we can cast to SegmentReader
- SegmentReader reader = (SegmentReader) IndexReader.open(ram);
+ SegmentReader reader = SegmentReader.getOnlySegmentReader(ram);
FieldInfos fi = reader.fieldInfos();
assertFalse("Payload field bit should not be set.", fi.fieldInfo("f1").storePayloads);
assertTrue("Payload field bit should be set.", fi.fieldInfo("f2").storePayloads);
@@ -142,8 +141,7 @@
// flush
writer.close();
- // only one segment in the index, so we can cast to SegmentReader
- reader = (SegmentReader) IndexReader.open(ram);
+ reader = SegmentReader.getOnlySegmentReader(ram);
fi = reader.fieldInfos();
assertFalse("Payload field bit should not be set.", fi.fieldInfo("f1").storePayloads);
assertTrue("Payload field bit should be set.", fi.fieldInfo("f2").storePayloads);
diff --git a/src/test/org/apache/lucene/index/TestSegmentTermEnum.java b/src/test/org/apache/lucene/index/TestSegmentTermEnum.java
--- a/src/test/org/apache/lucene/index/TestSegmentTermEnum.java
+++ b/src/test/org/apache/lucene/index/TestSegmentTermEnum.java
@@ -71,7 +71,7 @@
IndexWriter writer = new IndexWriter(dir, new WhitespaceAnalyzer(), true, IndexWriter.MaxFieldLength.LIMITED);
addDoc(writer, "aaa bbb");
writer.close();
- IndexReader reader = IndexReader.open(dir);
+ SegmentReader reader = SegmentReader.getOnlySegmentReader(dir);
SegmentTermEnum termEnum = (SegmentTermEnum) reader.terms();
assertTrue(termEnum.next());
assertEquals("aaa", termEnum.term().text());