=0;upto--) {
+ try {
+ readers[upto].close();
+ } catch (Throwable ignore) {
+ // keep going - we want to clean up as much as possible
+ }
+ }
+ }
+ }
+ }
+
+ this.writer = writer;
+
+ if (upto < readers.length) {
+ // This means some segments were in a foreign Directory
+ SegmentReader[] newReaders = new SegmentReader[upto];
+ System.arraycopy(readers, 0, newReaders, 0, upto);
+ readers = newReaders;
+ }
+
+ initialize(readers);
+ }
+
+ /** This contructor is only used for {@link #reopen()} */
+ DirectoryReader(Directory directory, SegmentInfos infos, boolean closeDirectory, SegmentReader[] oldReaders, int[] oldStarts,
+ Map oldNormsCache, boolean readOnly, boolean doClone) throws IOException {
+ this.directory = directory;
+ this.readOnly = readOnly;
+ this.closeDirectory = closeDirectory;
+ this.segmentInfos = infos;
+ if (!readOnly) {
+ // We assume that this segments_N was previously
+ // properly sync'd:
+ synced.addAll(infos.files(directory, true));
+ }
+
+ // we put the old SegmentReaders in a map, that allows us
+ // to lookup a reader using its segment name
+ Map segmentReaders = new HashMap();
+
+ if (oldReaders != null) {
+ // create a Map SegmentName->SegmentReader
+ for (int i = 0; i < oldReaders.length; i++) {
+ segmentReaders.put(oldReaders[i].getSegmentName(), new Integer(i));
+ }
+ }
+
+ SegmentReader[] newReaders = new SegmentReader[infos.size()];
+
+ // remember which readers are shared between the old and the re-opened
+ // DirectoryReader - we have to incRef those readers
+ boolean[] readerShared = new boolean[infos.size()];
+
+ for (int i = infos.size() - 1; i>=0; i--) {
+ // find SegmentReader for this segment
+ Integer oldReaderIndex = (Integer) segmentReaders.get(infos.info(i).name);
+ if (oldReaderIndex == null) {
+ // this is a new segment, no old SegmentReader can be reused
+ newReaders[i] = null;
+ } else {
+ // there is an old reader for this segment - we'll try to reopen it
+ newReaders[i] = oldReaders[oldReaderIndex.intValue()];
+ }
+
+ boolean success = false;
+ try {
+ SegmentReader newReader;
+ if (newReaders[i] == null || infos.info(i).getUseCompoundFile() != newReaders[i].getSegmentInfo().getUseCompoundFile()) {
+
+ // We should never see a totally new segment during cloning
+ assert !doClone;
+
+ // this is a new reader; in case we hit an exception we can close it safely
+ newReader = SegmentReader.get(readOnly, infos.info(i));
+ } else {
+ newReader = newReaders[i].reopenSegment(infos.info(i), doClone, readOnly);
+ }
+ if (newReader == newReaders[i]) {
+ // this reader will be shared between the old and the new one,
+ // so we must incRef it
+ readerShared[i] = true;
+ newReader.incRef();
+ } else {
+ readerShared[i] = false;
+ newReaders[i] = newReader;
+ }
+ success = true;
+ } finally {
+ if (!success) {
+ for (i++; i < infos.size(); i++) {
+ if (newReaders[i] != null) {
+ try {
+ if (!readerShared[i]) {
+ // this is a new subReader that is not used by the old one,
+ // we can close it
+ newReaders[i].close();
+ } else {
+ // this subReader is also used by the old reader, so instead
+ // closing we must decRef it
+ newReaders[i].decRef();
+ }
+ } catch (IOException ignore) {
+ // keep going - we want to clean up as much as possible
+ }
+ }
+ }
+ }
+ }
+ }
+
+ // initialize the readers to calculate maxDoc before we try to reuse the old normsCache
+ initialize(newReaders);
+
+ // try to copy unchanged norms from the old normsCache to the new one
+ if (oldNormsCache != null) {
+ Iterator it = oldNormsCache.entrySet().iterator();
+ while (it.hasNext()) {
+ Map.Entry entry = (Map.Entry) it.next();
+ String field = (String) entry.getKey();
+ if (!hasNorms(field)) {
+ continue;
+ }
+
+ byte[] oldBytes = (byte[]) entry.getValue();
+
+ byte[] bytes = new byte[maxDoc()];
+
+ for (int i = 0; i < subReaders.length; i++) {
+ Integer oldReaderIndex = ((Integer) segmentReaders.get(subReaders[i].getSegmentName()));
+
+ // this SegmentReader was not re-opened, we can copy all of its norms
+ if (oldReaderIndex != null &&
+ (oldReaders[oldReaderIndex.intValue()] == subReaders[i]
+ || oldReaders[oldReaderIndex.intValue()].norms.get(field) == subReaders[i].norms.get(field))) {
+ // we don't have to synchronize here: either this constructor is called from a SegmentReader,
+ // in which case no old norms cache is present, or it is called from MultiReader.reopen(),
+ // which is synchronized
+ System.arraycopy(oldBytes, oldStarts[oldReaderIndex.intValue()], bytes, starts[i], starts[i+1] - starts[i]);
+ } else {
+ subReaders[i].norms(field, bytes, starts[i]);
+ }
+ }
+
+ normsCache.put(field, bytes); // update cache
+ }
+ }
+ }
+
+ private void initialize(SegmentReader[] subReaders) {
+ this.subReaders = subReaders;
+ starts = new int[subReaders.length + 1]; // build starts array
+ for (int i = 0; i < subReaders.length; i++) {
+ starts[i] = maxDoc;
+ maxDoc += subReaders[i].maxDoc(); // compute maxDocs
+
+ if (subReaders[i].hasDeletions())
+ hasDeletions = true;
+ }
+ starts[subReaders.length] = maxDoc;
+ }
+
+ public final synchronized Object clone() {
+ try {
+ return clone(readOnly); // Preserve current readOnly
+ } catch (Exception ex) {
+ throw new RuntimeException(ex);
+ }
+ }
+
+ public final synchronized IndexReader clone(boolean openReadOnly) throws CorruptIndexException, IOException {
+ DirectoryReader newReader = doReopen((SegmentInfos) segmentInfos.clone(), true, openReadOnly);
+
+ if (this != newReader) {
+ newReader.closeDirectory = closeDirectory;
+ newReader.deletionPolicy = deletionPolicy;
+ }
+ newReader.writer = writer;
+ // If we're cloning a non-readOnly reader, move the
+ // writeLock (if there is one) to the new reader:
+ if (!openReadOnly && writeLock != null) {
+ // In near real-time search, reader is always readonly
+ assert writer == null;
+ newReader.writeLock = writeLock;
+ newReader.hasChanges = hasChanges;
+ newReader.hasDeletions = hasDeletions;
+ writeLock = null;
+ hasChanges = false;
+ }
+
+ return newReader;
+ }
+
+ public final synchronized IndexReader reopen() throws CorruptIndexException, IOException {
+ // Preserve current readOnly
+ return doReopen(readOnly, null);
+ }
+
+ public final synchronized IndexReader reopen(boolean openReadOnly) throws CorruptIndexException, IOException {
+ return doReopen(openReadOnly, null);
+ }
+
+ public final synchronized IndexReader reopen(final IndexCommit commit) throws CorruptIndexException, IOException {
+ return doReopen(true, commit);
+ }
+
+ private synchronized IndexReader doReopen(final boolean openReadOnly, IndexCommit commit) throws CorruptIndexException, IOException {
+ ensureOpen();
+
+ assert commit == null || openReadOnly;
+
+ // If we were obtained by writer.getReader(), re-ask the
+ // writer to get a new reader.
+ if (writer != null) {
+ assert readOnly;
+
+ if (!openReadOnly) {
+ throw new IllegalArgumentException("a reader obtained from IndexWriter.getReader() can only be reopened with openReadOnly=true (got false)");
+ }
+
+ if (commit != null) {
+ throw new IllegalArgumentException("a reader obtained from IndexWriter.getReader() cannot currently accept a commit");
+ }
+
+ if (!writer.isOpen(true)) {
+ throw new AlreadyClosedException("cannot reopen: the IndexWriter this reader was obtained from is now closed");
+ }
+
+ // TODO: right now we *always* make a new reader; in
+ // the future we could have write make some effort to
+ // detect that no changes have occurred
+ IndexReader reader = writer.getReader();
+ reader.setDisableFakeNorms(getDisableFakeNorms());
+ return reader;
+ }
+
+ if (commit == null) {
+ if (hasChanges) {
+ // We have changes, which means we are not readOnly:
+ assert readOnly == false;
+ // and we hold the write lock:
+ assert writeLock != null;
+ // so no other writer holds the write lock, which
+ // means no changes could have been done to the index:
+ assert isCurrent();
+
+ if (openReadOnly) {
+ return (IndexReader) clone(openReadOnly);
+ } else {
+ return this;
+ }
+ } else if (isCurrent()) {
+ if (openReadOnly != readOnly) {
+ // Just fallback to clone
+ return (IndexReader) clone(openReadOnly);
+ } else {
+ return this;
+ }
+ }
+ } else {
+ if (directory != commit.getDirectory())
+ throw new IOException("the specified commit does not match the specified Directory");
+ if (segmentInfos != null && commit.getSegmentsFileName().equals(segmentInfos.getCurrentSegmentFileName())) {
+ if (readOnly != openReadOnly) {
+ // Just fallback to clone
+ return (IndexReader) clone(openReadOnly);
+ } else {
+ return this;
+ }
+ }
+ }
+
+ final SegmentInfos.FindSegmentsFile finder = new SegmentInfos.FindSegmentsFile(directory) {
+
+ protected Object doBody(String segmentFileName) throws CorruptIndexException, IOException {
+ SegmentInfos infos = new SegmentInfos();
+ infos.read(directory, segmentFileName);
+ return doReopen(infos, false, openReadOnly);
+ }
+ };
+
+ DirectoryReader reader = null;
+
+ // While trying to reopen, we temporarily mark our
+ // closeDirectory as false. This way any exceptions hit
+ // partway while opening the reader, which is expected
+ // eg if writer is committing, won't close our
+ // directory. We restore this value below:
+ final boolean myCloseDirectory = closeDirectory;
+ closeDirectory = false;
+
+ try {
+ reader = (DirectoryReader) finder.run(commit);
+ } finally {
+ if (myCloseDirectory) {
+ assert directory instanceof FSDirectory;
+ // Restore my closeDirectory
+ closeDirectory = true;
+ if (reader != null && reader != this) {
+ // Success, and a new reader was actually opened
+ reader.closeDirectory = true;
+ // Clone the directory
+ reader.directory = FSDirectory.getDirectory(((FSDirectory) directory).getFile());
+ }
+ }
+ }
+
+ return reader;
+ }
+
+ private synchronized DirectoryReader doReopen(SegmentInfos infos, boolean doClone, boolean openReadOnly) throws CorruptIndexException, IOException {
+ DirectoryReader reader;
+ if (openReadOnly) {
+ reader = new ReadOnlyDirectoryReader(directory, infos, closeDirectory, subReaders, starts, normsCache, doClone);
+ } else {
+ reader = new DirectoryReader(directory, infos, closeDirectory, subReaders, starts, normsCache, false, doClone);
+ }
+ reader.setDisableFakeNorms(getDisableFakeNorms());
+ return reader;
+ }
+
+ /** Version number when this IndexReader was opened. */
+ public long getVersion() {
+ ensureOpen();
+ return segmentInfos.getVersion();
+ }
+
+ public TermFreqVector[] getTermFreqVectors(int n) throws IOException {
+ ensureOpen();
+ int i = readerIndex(n); // find segment num
+ return subReaders[i].getTermFreqVectors(n - starts[i]); // dispatch to segment
+ }
+
+ public TermFreqVector getTermFreqVector(int n, String field)
+ throws IOException {
+ ensureOpen();
+ int i = readerIndex(n); // find segment num
+ return subReaders[i].getTermFreqVector(n - starts[i], field);
+ }
+
+
+ public void getTermFreqVector(int docNumber, String field, TermVectorMapper mapper) throws IOException {
+ ensureOpen();
+ int i = readerIndex(docNumber); // find segment num
+ subReaders[i].getTermFreqVector(docNumber - starts[i], field, mapper);
+ }
+
+ public void getTermFreqVector(int docNumber, TermVectorMapper mapper) throws IOException {
+ ensureOpen();
+ int i = readerIndex(docNumber); // find segment num
+ subReaders[i].getTermFreqVector(docNumber - starts[i], mapper);
+ }
+
+ /**
+ * Checks is the index is optimized (if it has a single segment and no deletions)
+ * @return true if the index is optimized; false otherwise
+ */
+ public boolean isOptimized() {
+ ensureOpen();
+ return segmentInfos.size() == 1 && !hasDeletions();
+ }
+
+ public synchronized int numDocs() {
+ // Don't call ensureOpen() here (it could affect performance)
+ if (numDocs == -1) { // check cache
+ int n = 0; // cache miss--recompute
+ for (int i = 0; i < subReaders.length; i++)
+ n += subReaders[i].numDocs(); // sum from readers
+ numDocs = n;
+ }
+ return numDocs;
+ }
+
+ public int maxDoc() {
+ // Don't call ensureOpen() here (it could affect performance)
+ return maxDoc;
+ }
+
+ // inherit javadoc
+ public Document document(int n, FieldSelector fieldSelector) throws CorruptIndexException, IOException {
+ ensureOpen();
+ int i = readerIndex(n); // find segment num
+ return subReaders[i].document(n - starts[i], fieldSelector); // dispatch to segment reader
+ }
+
+ public boolean isDeleted(int n) {
+ // Don't call ensureOpen() here (it could affect performance)
+ final int i = readerIndex(n); // find segment num
+ return subReaders[i].isDeleted(n - starts[i]); // dispatch to segment reader
+ }
+
+ public boolean hasDeletions() {
+ // Don't call ensureOpen() here (it could affect performance)
+ return hasDeletions;
+ }
+
+ protected void doDelete(int n) throws CorruptIndexException, IOException {
+ numDocs = -1; // invalidate cache
+ int i = readerIndex(n); // find segment num
+ subReaders[i].deleteDocument(n - starts[i]); // dispatch to segment reader
+ hasDeletions = true;
+ }
+
+ protected void doUndeleteAll() throws CorruptIndexException, IOException {
+ for (int i = 0; i < subReaders.length; i++)
+ subReaders[i].undeleteAll();
+
+ hasDeletions = false;
+ numDocs = -1; // invalidate cache
+ }
+
+ private int readerIndex(int n) { // find reader for doc n:
+ return readerIndex(n, this.starts, this.subReaders.length);
+ }
+
+ final static int readerIndex(int n, int[] starts, int numSubReaders) { // find reader for doc n:
+ int lo = 0; // search starts array
+ int hi = numSubReaders - 1; // for first element less
+
+ while (hi >= lo) {
+ int mid = (lo + hi) >>> 1;
+ int midValue = starts[mid];
+ if (n < midValue)
+ hi = mid - 1;
+ else if (n > midValue)
+ lo = mid + 1;
+ else { // found a match
+ while (mid+1 < numSubReaders && starts[mid+1] == midValue) {
+ mid++; // scan to last match
+ }
+ return mid;
+ }
+ }
+ return hi;
+ }
+
+ public boolean hasNorms(String field) throws IOException {
+ ensureOpen();
+ for (int i = 0; i < subReaders.length; i++) {
+ if (subReaders[i].hasNorms(field)) return true;
+ }
+ return false;
+ }
+
+ private byte[] ones;
+ private byte[] fakeNorms() {
+ if (ones==null) ones=SegmentReader.createFakeNorms(maxDoc());
+ return ones;
+ }
+
+ public synchronized byte[] norms(String field) throws IOException {
+ ensureOpen();
+ byte[] bytes = (byte[])normsCache.get(field);
+ if (bytes != null)
+ return bytes; // cache hit
+ if (!hasNorms(field))
+ return getDisableFakeNorms() ? null : fakeNorms();
+
+ bytes = new byte[maxDoc()];
+ for (int i = 0; i < subReaders.length; i++)
+ subReaders[i].norms(field, bytes, starts[i]);
+ normsCache.put(field, bytes); // update cache
+ return bytes;
+ }
+
+ public synchronized void norms(String field, byte[] result, int offset)
+ throws IOException {
+ ensureOpen();
+ byte[] bytes = (byte[])normsCache.get(field);
+ if (bytes==null && !hasNorms(field)) {
+ Arrays.fill(result, offset, result.length, DefaultSimilarity.encodeNorm(1.0f));
+ } else if (bytes != null) { // cache hit
+ System.arraycopy(bytes, 0, result, offset, maxDoc());
+ } else {
+ for (int i = 0; i < subReaders.length; i++) { // read from segments
+ subReaders[i].norms(field, result, offset + starts[i]);
+ }
+ }
+ }
+
+ protected void doSetNorm(int n, String field, byte value)
+ throws CorruptIndexException, IOException {
+ synchronized (normsCache) {
+ normsCache.remove(field); // clear cache
+ }
+ int i = readerIndex(n); // find segment num
+ subReaders[i].setNorm(n-starts[i], field, value); // dispatch
+ }
+
+ public TermEnum terms() throws IOException {
+ ensureOpen();
+ return new MultiTermEnum(this, subReaders, starts, null);
+ }
+
+ public TermEnum terms(Term term) throws IOException {
+ ensureOpen();
+ return new MultiTermEnum(this, subReaders, starts, term);
+ }
+
+ public int docFreq(Term t) throws IOException {
+ ensureOpen();
+ int total = 0; // sum freqs in segments
+ for (int i = 0; i < subReaders.length; i++)
+ total += subReaders[i].docFreq(t);
+ return total;
+ }
+
+ public TermDocs termDocs() throws IOException {
+ ensureOpen();
+ return new MultiTermDocs(this, subReaders, starts);
+ }
+
+ public TermPositions termPositions() throws IOException {
+ ensureOpen();
+ return new MultiTermPositions(this, subReaders, starts);
+ }
+
+ /**
+ * 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() {
+ rollbackHasChanges = hasChanges;
+ rollbackSegmentInfos = (SegmentInfos) segmentInfos.clone();
+ for (int i = 0; i < subReaders.length; i++) {
+ subReaders[i].startCommit();
+ }
+ }
+
+ void 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();
+
+ if (closeDirectory)
+ directory.close();
+ }
+
+ public Collection getFieldNames (IndexReader.FieldOption fieldNames) {
+ ensureOpen();
+ return getFieldNames(fieldNames, this.subReaders);
+ }
+
+ static Collection getFieldNames (IndexReader.FieldOption fieldNames, IndexReader[] subReaders) {
+ // maintain a unique set of field names
+ Set fieldSet = new HashSet();
+ for (int i = 0; i < subReaders.length; i++) {
+ IndexReader reader = subReaders[i];
+ Collection names = reader.getFieldNames(fieldNames);
+ fieldSet.addAll(names);
+ }
+ return fieldSet;
+ }
+
+ public IndexReader[] getSequentialSubReaders() {
+ return subReaders;
+ }
+
+ public void setTermInfosIndexDivisor(int indexDivisor) throws IllegalStateException {
+ for (int i = 0; i < subReaders.length; i++)
+ subReaders[i].setTermInfosIndexDivisor(indexDivisor);
+ }
+
+ public int getTermInfosIndexDivisor() throws IllegalStateException {
+ if (subReaders.length > 0)
+ return subReaders[0].getTermInfosIndexDivisor();
+ else
+ throw new IllegalStateException("no readers");
+ }
+
+ public void setDisableFakeNorms(boolean disableFakeNorms) {
+ super.setDisableFakeNorms(disableFakeNorms);
+ for (int i = 0; i < subReaders.length; i++)
+ 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 0) {
+ next();
+ }
+ }
+
+ public boolean next() throws IOException {
+ for (int i=0; i
- * NOTE: for a MultiSegmentReader, which is obtained by
- * {@link #open} when the index has more than one
- * segment, you should not use the sub-readers returned
- * by this method to make any changes (setNorm,
- * deleteDocument, etc.). Doing so will likely lead to
- * index corruption. Use the parent reader instead. */
+ * NOTE: You should not try using sub-readers returned by
+ * this method to make any changes (setNorm, deleteDocument,
+ * etc.). While this might succeed for one composite reader
+ * (like MultiReader), it will most likely lead to index
+ * corruption for other readers (like DirectoryReader obtained
+ * through {@link #open}. Use the parent reader directly. */
public IndexReader[] getSequentialSubReaders() {
return null;
}
diff --git a/src/java/org/apache/lucene/index/IndexWriter.java b/src/java/org/apache/lucene/index/IndexWriter.java
--- a/src/java/org/apache/lucene/index/IndexWriter.java
+++ b/src/java/org/apache/lucene/index/IndexWriter.java
@@ -440,7 +440,7 @@
// reader; in theory we could do similar retry logic,
// just like we do when loading segments_N
synchronized(this) {
- return new ReadOnlyMultiSegmentReader(this, segmentInfos);
+ return new ReadOnlyDirectoryReader(this, segmentInfos);
}
}
@@ -616,7 +616,6 @@
// synchronized
// Returns a ref, which we xfer to readerMap:
sr = SegmentReader.get(info, readBufferSize, doOpenStores);
- sr.writer = IndexWriter.this;
readerMap.put(info, sr);
} else if (doOpenStores) {
sr.openDocStores();
diff --git a/src/java/org/apache/lucene/index/MultiReader.java b/src/java/org/apache/lucene/index/MultiReader.java
--- a/src/java/org/apache/lucene/index/MultiReader.java
+++ b/src/java/org/apache/lucene/index/MultiReader.java
@@ -25,9 +25,9 @@
import org.apache.lucene.document.Document;
import org.apache.lucene.document.FieldSelector;
-import org.apache.lucene.index.MultiSegmentReader.MultiTermDocs;
-import org.apache.lucene.index.MultiSegmentReader.MultiTermEnum;
-import org.apache.lucene.index.MultiSegmentReader.MultiTermPositions;
+import org.apache.lucene.index.DirectoryReader.MultiTermDocs;
+import org.apache.lucene.index.DirectoryReader.MultiTermEnum;
+import org.apache.lucene.index.DirectoryReader.MultiTermPositions;
import org.apache.lucene.search.DefaultSimilarity;
/** An IndexReader which reads multiple indexes, appending their content.
@@ -268,7 +268,7 @@
}
private int readerIndex(int n) { // find reader for doc n:
- return MultiSegmentReader.readerIndex(n, this.starts, this.subReaders.length);
+ return DirectoryReader.readerIndex(n, this.starts, this.subReaders.length);
}
public boolean hasNorms(String field) throws IOException {
@@ -377,7 +377,7 @@
public Collection getFieldNames (IndexReader.FieldOption fieldNames) {
ensureOpen();
- return MultiSegmentReader.getFieldNames(fieldNames, this.subReaders);
+ return DirectoryReader.getFieldNames(fieldNames, this.subReaders);
}
/**
diff --git a/src/java/org/apache/lucene/index/MultiSegmentReader.java b/src/java/org/apache/lucene/index/MultiSegmentReader.java
deleted file mode 100644
--- a/src/java/org/apache/lucene/index/MultiSegmentReader.java
+++ /dev/null
@@ -1,791 +0,0 @@
-package org.apache.lucene.index;
-
-/**
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import java.io.IOException;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.Map;
-import java.util.Set;
-
-import org.apache.lucene.document.Document;
-import org.apache.lucene.document.FieldSelector;
-import org.apache.lucene.search.DefaultSimilarity;
-import org.apache.lucene.store.Directory;
-
-/**
- * An IndexReader which reads indexes with multiple segments.
- */
-class MultiSegmentReader extends DirectoryIndexReader implements Cloneable {
- protected SegmentReader[] subReaders;
- private int[] starts; // 1st docno for each segment
- private Map normsCache = new HashMap();
- private int maxDoc = 0;
- private int numDocs = -1;
- private boolean hasDeletions = false;
-
- /** Construct reading the named set of readers. */
- MultiSegmentReader(Directory directory, SegmentInfos sis, boolean closeDirectory, boolean readOnly) throws IOException {
- super(directory, sis, closeDirectory, readOnly);
-
- // To reduce the chance of hitting FileNotFound
- // (and having to retry), we open segments in
- // reverse because IndexWriter merges & deletes
- // the newest segments first.
-
- SegmentReader[] readers = new SegmentReader[sis.size()];
- for (int i = sis.size()-1; i >= 0; i--) {
- boolean success = false;
- try {
- readers[i] = SegmentReader.get(readOnly, sis.info(i));
- success = true;
- } finally {
- if (!success) {
- // Close all readers we had opened:
- for(i++;i=0;upto--) {
- try {
- readers[upto].close();
- } catch (Throwable ignore) {
- // keep going - we want to clean up as much as possible
- }
- }
- }
- }
- }
-
- this.writer = writer;
-
- if (upto < readers.length) {
- // This means some segments were in a foreign Directory
- SegmentReader[] newReaders = new SegmentReader[upto];
- System.arraycopy(readers, 0, newReaders, 0, upto);
- readers = newReaders;
- }
-
- initialize(readers);
- }
-
- /** This contructor is only used for {@link #reopen()} */
- MultiSegmentReader(Directory directory, SegmentInfos infos, boolean closeDirectory, SegmentReader[] oldReaders, int[] oldStarts,
- Map oldNormsCache, boolean readOnly, boolean doClone) throws IOException {
- super(directory, infos, closeDirectory, readOnly);
-
- // we put the old SegmentReaders in a map, that allows us
- // to lookup a reader using its segment name
- Map segmentReaders = new HashMap();
-
- if (oldReaders != null) {
- // create a Map SegmentName->SegmentReader
- for (int i = 0; i < oldReaders.length; i++) {
- segmentReaders.put(oldReaders[i].getSegmentName(), new Integer(i));
- }
- }
-
- SegmentReader[] newReaders = new SegmentReader[infos.size()];
-
- // remember which readers are shared between the old and the re-opened
- // MultiSegmentReader - we have to incRef those readers
- boolean[] readerShared = new boolean[infos.size()];
-
- for (int i = infos.size() - 1; i>=0; i--) {
- // find SegmentReader for this segment
- Integer oldReaderIndex = (Integer) segmentReaders.get(infos.info(i).name);
- if (oldReaderIndex == null) {
- // this is a new segment, no old SegmentReader can be reused
- newReaders[i] = null;
- } else {
- // there is an old reader for this segment - we'll try to reopen it
- newReaders[i] = oldReaders[oldReaderIndex.intValue()];
- }
-
- boolean success = false;
- try {
- SegmentReader newReader;
- if (newReaders[i] == null || infos.info(i).getUseCompoundFile() != newReaders[i].getSegmentInfo().getUseCompoundFile()) {
-
- // We should never see a totally new segment during cloning
- assert !doClone;
-
- // this is a new reader; in case we hit an exception we can close it safely
- newReader = SegmentReader.get(readOnly, infos.info(i));
- } else {
- newReader = (SegmentReader) newReaders[i].reopenSegment(infos.info(i), doClone, readOnly);
- if (newReader == newReaders[i] && newReaders[i].hasSegmentInfos()) {
- // Special case when a single-segment reader was
- // reopened to a multi-segment reader -- we must
- // get a private clone, to clear its
- // SegmentInfos, so it does not attempt to
- // obtain the write lock
- newReader = (SegmentReader) newReaders[i].clone(readOnly);
- newReader.init(directory, null, false, readOnly);
- }
-
- // Make sure reopenSegment did not carry over a
- // segmentInfos instance
- assert !newReader.hasSegmentInfos();
- }
- if (newReader == newReaders[i]) {
- // this reader will be shared between the old and the new one,
- // so we must incRef it
- readerShared[i] = true;
- newReader.incRef();
- } else {
- readerShared[i] = false;
- newReaders[i] = newReader;
- }
- success = true;
- } finally {
- if (!success) {
- for (i++; i < infos.size(); i++) {
- if (newReaders[i] != null) {
- try {
- if (!readerShared[i]) {
- // this is a new subReader that is not used by the old one,
- // we can close it
- newReaders[i].close();
- } else {
- // this subReader is also used by the old reader, so instead
- // closing we must decRef it
- newReaders[i].decRef();
- }
- } catch (IOException ignore) {
- // keep going - we want to clean up as much as possible
- }
- }
- }
- }
- }
- }
-
- // initialize the readers to calculate maxDoc before we try to reuse the old normsCache
- initialize(newReaders);
-
- // try to copy unchanged norms from the old normsCache to the new one
- if (oldNormsCache != null) {
- Iterator it = oldNormsCache.entrySet().iterator();
- while (it.hasNext()) {
- Map.Entry entry = (Map.Entry) it.next();
- String field = (String) entry.getKey();
- if (!hasNorms(field)) {
- continue;
- }
-
- byte[] oldBytes = (byte[]) entry.getValue();
-
- byte[] bytes = new byte[maxDoc()];
-
- for (int i = 0; i < subReaders.length; i++) {
- Integer oldReaderIndex = ((Integer) segmentReaders.get(subReaders[i].getSegmentName()));
-
- // this SegmentReader was not re-opened, we can copy all of its norms
- if (oldReaderIndex != null &&
- (oldReaders[oldReaderIndex.intValue()] == subReaders[i]
- || oldReaders[oldReaderIndex.intValue()].norms.get(field) == subReaders[i].norms.get(field))) {
- // we don't have to synchronize here: either this constructor is called from a SegmentReader,
- // in which case no old norms cache is present, or it is called from MultiReader.reopen(),
- // which is synchronized
- System.arraycopy(oldBytes, oldStarts[oldReaderIndex.intValue()], bytes, starts[i], starts[i+1] - starts[i]);
- } else {
- subReaders[i].norms(field, bytes, starts[i]);
- }
- }
-
- normsCache.put(field, bytes); // update cache
- }
- }
- }
-
- private void initialize(SegmentReader[] subReaders) {
- this.subReaders = subReaders;
- starts = new int[subReaders.length + 1]; // build starts array
- for (int i = 0; i < subReaders.length; i++) {
- starts[i] = maxDoc;
- maxDoc += subReaders[i].maxDoc(); // compute maxDocs
-
- if (subReaders[i].hasDeletions())
- hasDeletions = true;
- }
- starts[subReaders.length] = maxDoc;
- }
-
- protected synchronized DirectoryIndexReader doReopen(SegmentInfos infos, boolean doClone, boolean openReadOnly) throws CorruptIndexException, IOException {
- DirectoryIndexReader reader;
- if (infos.size() == 1) {
- // The index has only one segment now, so we can't refresh the MultiSegmentReader.
- // Return a new [ReadOnly]SegmentReader instead
- reader = SegmentReader.get(openReadOnly, infos, infos.info(0), false);
- } else if (openReadOnly) {
- reader = new ReadOnlyMultiSegmentReader(directory, infos, closeDirectory, subReaders, starts, normsCache, doClone);
- } else {
- reader = new MultiSegmentReader(directory, infos, closeDirectory, subReaders, starts, normsCache, false, doClone);
- }
- reader.setDisableFakeNorms(getDisableFakeNorms());
- return reader;
- }
-
- public TermFreqVector[] getTermFreqVectors(int n) throws IOException {
- ensureOpen();
- int i = readerIndex(n); // find segment num
- return subReaders[i].getTermFreqVectors(n - starts[i]); // dispatch to segment
- }
-
- public TermFreqVector getTermFreqVector(int n, String field)
- throws IOException {
- ensureOpen();
- int i = readerIndex(n); // find segment num
- return subReaders[i].getTermFreqVector(n - starts[i], field);
- }
-
-
- public void getTermFreqVector(int docNumber, String field, TermVectorMapper mapper) throws IOException {
- ensureOpen();
- int i = readerIndex(docNumber); // find segment num
- subReaders[i].getTermFreqVector(docNumber - starts[i], field, mapper);
- }
-
- public void getTermFreqVector(int docNumber, TermVectorMapper mapper) throws IOException {
- ensureOpen();
- int i = readerIndex(docNumber); // find segment num
- subReaders[i].getTermFreqVector(docNumber - starts[i], mapper);
- }
-
- public boolean isOptimized() {
- return false;
- }
-
- public synchronized int numDocs() {
- // Don't call ensureOpen() here (it could affect performance)
- if (numDocs == -1) { // check cache
- int n = 0; // cache miss--recompute
- for (int i = 0; i < subReaders.length; i++)
- n += subReaders[i].numDocs(); // sum from readers
- numDocs = n;
- }
- return numDocs;
- }
-
- public int maxDoc() {
- // Don't call ensureOpen() here (it could affect performance)
- return maxDoc;
- }
-
- // inherit javadoc
- public Document document(int n, FieldSelector fieldSelector) throws CorruptIndexException, IOException {
- ensureOpen();
- int i = readerIndex(n); // find segment num
- return subReaders[i].document(n - starts[i], fieldSelector); // dispatch to segment reader
- }
-
- public boolean isDeleted(int n) {
- // Don't call ensureOpen() here (it could affect performance)
- final int i = readerIndex(n); // find segment num
- return subReaders[i].isDeleted(n - starts[i]); // dispatch to segment reader
- }
-
- public boolean hasDeletions() {
- // Don't call ensureOpen() here (it could affect performance)
- return hasDeletions;
- }
-
- protected void doDelete(int n) throws CorruptIndexException, IOException {
- numDocs = -1; // invalidate cache
- int i = readerIndex(n); // find segment num
- subReaders[i].deleteDocument(n - starts[i]); // dispatch to segment reader
- hasDeletions = true;
- }
-
- protected void doUndeleteAll() throws CorruptIndexException, IOException {
- for (int i = 0; i < subReaders.length; i++)
- subReaders[i].undeleteAll();
-
- hasDeletions = false;
- numDocs = -1; // invalidate cache
- }
-
- private int readerIndex(int n) { // find reader for doc n:
- return readerIndex(n, this.starts, this.subReaders.length);
- }
-
- final static int readerIndex(int n, int[] starts, int numSubReaders) { // find reader for doc n:
- int lo = 0; // search starts array
- int hi = numSubReaders - 1; // for first element less
-
- while (hi >= lo) {
- int mid = (lo + hi) >>> 1;
- int midValue = starts[mid];
- if (n < midValue)
- hi = mid - 1;
- else if (n > midValue)
- lo = mid + 1;
- else { // found a match
- while (mid+1 < numSubReaders && starts[mid+1] == midValue) {
- mid++; // scan to last match
- }
- return mid;
- }
- }
- return hi;
- }
-
- public boolean hasNorms(String field) throws IOException {
- ensureOpen();
- for (int i = 0; i < subReaders.length; i++) {
- if (subReaders[i].hasNorms(field)) return true;
- }
- return false;
- }
-
- private byte[] ones;
- private byte[] fakeNorms() {
- if (ones==null) ones=SegmentReader.createFakeNorms(maxDoc());
- return ones;
- }
-
- public synchronized byte[] norms(String field) throws IOException {
- ensureOpen();
- byte[] bytes = (byte[])normsCache.get(field);
- if (bytes != null)
- return bytes; // cache hit
- if (!hasNorms(field))
- return getDisableFakeNorms() ? null : fakeNorms();
-
- bytes = new byte[maxDoc()];
- for (int i = 0; i < subReaders.length; i++)
- subReaders[i].norms(field, bytes, starts[i]);
- normsCache.put(field, bytes); // update cache
- return bytes;
- }
-
- public synchronized void norms(String field, byte[] result, int offset)
- throws IOException {
- ensureOpen();
- byte[] bytes = (byte[])normsCache.get(field);
- if (bytes==null && !hasNorms(field)) {
- Arrays.fill(result, offset, result.length, DefaultSimilarity.encodeNorm(1.0f));
- } else if (bytes != null) { // cache hit
- System.arraycopy(bytes, 0, result, offset, maxDoc());
- } else {
- for (int i = 0; i < subReaders.length; i++) { // read from segments
- subReaders[i].norms(field, result, offset + starts[i]);
- }
- }
- }
-
- protected void doSetNorm(int n, String field, byte value)
- throws CorruptIndexException, IOException {
- synchronized (normsCache) {
- normsCache.remove(field); // clear cache
- }
- int i = readerIndex(n); // find segment num
- subReaders[i].setNorm(n-starts[i], field, value); // dispatch
- }
-
- public TermEnum terms() throws IOException {
- ensureOpen();
- return new MultiTermEnum(this, subReaders, starts, null);
- }
-
- public TermEnum terms(Term term) throws IOException {
- ensureOpen();
- return new MultiTermEnum(this, subReaders, starts, term);
- }
-
- public int docFreq(Term t) throws IOException {
- ensureOpen();
- int total = 0; // sum freqs in segments
- for (int i = 0; i < subReaders.length; i++)
- total += subReaders[i].docFreq(t);
- return total;
- }
-
- public TermDocs termDocs() throws IOException {
- ensureOpen();
- return new MultiTermDocs(this, subReaders, starts);
- }
-
- public TermPositions termPositions() throws IOException {
- ensureOpen();
- return new MultiTermPositions(this, subReaders, starts);
- }
-
- protected void commitChanges() throws IOException {
- for (int i = 0; i < subReaders.length; i++)
- subReaders[i].commit();
- }
-
- void startCommit() {
- super.startCommit();
- for (int i = 0; i < subReaders.length; i++) {
- subReaders[i].startCommit();
- }
- }
-
- void rollbackCommit() {
- super.rollbackCommit();
- for (int i = 0; i < subReaders.length; i++) {
- subReaders[i].rollbackCommit();
- }
- }
-
- protected synchronized void doClose() throws IOException {
- for (int i = 0; i < subReaders.length; i++)
- subReaders[i].decRef();
-
- // maybe close directory
- super.doClose();
- }
-
- public Collection getFieldNames (IndexReader.FieldOption fieldNames) {
- ensureOpen();
- return getFieldNames(fieldNames, this.subReaders);
- }
-
- static Collection getFieldNames (IndexReader.FieldOption fieldNames, IndexReader[] subReaders) {
- // maintain a unique set of field names
- Set fieldSet = new HashSet();
- for (int i = 0; i < subReaders.length; i++) {
- IndexReader reader = subReaders[i];
- Collection names = reader.getFieldNames(fieldNames);
- fieldSet.addAll(names);
- }
- return fieldSet;
- }
-
- public IndexReader[] getSequentialSubReaders() {
- return subReaders;
- }
-
- public void setTermInfosIndexDivisor(int indexDivisor) throws IllegalStateException {
- for (int i = 0; i < subReaders.length; i++)
- subReaders[i].setTermInfosIndexDivisor(indexDivisor);
- }
-
- public int getTermInfosIndexDivisor() throws IllegalStateException {
- if (subReaders.length > 0)
- return subReaders[0].getTermInfosIndexDivisor();
- else
- throw new IllegalStateException("no readers");
- }
-
- public void setDisableFakeNorms(boolean disableFakeNorms) {
- super.setDisableFakeNorms(disableFakeNorms);
- for (int i = 0; i < subReaders.length; i++)
- subReaders[i].setDisableFakeNorms(disableFakeNorms);
- }
-
- static class MultiTermEnum extends TermEnum {
- IndexReader topReader; // used for matching TermEnum to TermDocs
- private SegmentMergeQueue queue;
-
- private Term term;
- private int docFreq;
- final SegmentMergeInfo[] matchingSegments; // null terminated array of matching segments
-
- public MultiTermEnum(IndexReader topReader, IndexReader[] readers, int[] starts, Term t)
- throws IOException {
- this.topReader = topReader;
- queue = new SegmentMergeQueue(readers.length);
- matchingSegments = new SegmentMergeInfo[readers.length+1];
- for (int i = 0; i < readers.length; i++) {
- IndexReader reader = readers[i];
- TermEnum termEnum;
-
- if (t != null) {
- termEnum = reader.terms(t);
- } else
- termEnum = reader.terms();
-
- SegmentMergeInfo smi = new SegmentMergeInfo(starts[i], termEnum, reader);
- smi.ord = i;
- if (t == null ? smi.next() : termEnum.term() != null)
- queue.put(smi); // initialize queue
- else
- smi.close();
- }
-
- if (t != null && queue.size() > 0) {
- next();
- }
- }
-
- public boolean next() throws IOException {
- for (int i=0; i 0);
+ }
+
+ public void testAllTermDocs() throws IOException {
+ IndexReader reader = openReader();
+ int NUM_DOCS = 2;
+ TermDocs td = reader.termDocs(null);
+ 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 DirectoryReader);
+ 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 ReadOnlyDirectoryReader);
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 ReadOnlyDirectoryReader);
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");
}
@@ -218,12 +218,12 @@
return !exception;
}
- public void testCloneReadOnlyMultiSegmentReader() throws Exception {
+ public void testCloneReadOnlyDirectoryReader() throws Exception {
final Directory dir1 = new MockRAMDirectory();
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");
}
@@ -234,7 +234,7 @@
public static boolean isReadOnly(IndexReader r) {
if (r instanceof ReadOnlySegmentReader
- || r instanceof ReadOnlyMultiSegmentReader)
+ || r instanceof ReadOnlyDirectoryReader)
return true;
return false;
}
@@ -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
@@ -349,7 +349,7 @@
IndexReader reader0 = IndexReader.open(dir1);
assertRefCountEquals(1, reader0);
- assertTrue(reader0 instanceof MultiSegmentReader);
+ assertTrue(reader0 instanceof DirectoryReader);
IndexReader[] subReaders0 = reader0.getSequentialSubReaders();
for (int i = 0; i < subReaders0.length; i++) {
assertRefCountEquals(1, subReaders0[i]);
@@ -361,7 +361,7 @@
modifier.close();
IndexReader reader1 = refreshReader(reader0, true).refreshedReader;
- assertTrue(reader1 instanceof MultiSegmentReader);
+ assertTrue(reader1 instanceof DirectoryReader);
IndexReader[] subReaders1 = reader1.getSequentialSubReaders();
assertEquals(subReaders0.length, subReaders1.length);
@@ -380,7 +380,7 @@
modifier.close();
IndexReader reader2 = refreshReader(reader1, true).refreshedReader;
- assertTrue(reader2 instanceof MultiSegmentReader);
+ assertTrue(reader2 instanceof DirectoryReader);
IndexReader[] subReaders2 = reader2.getSequentialSubReaders();
assertEquals(subReaders1.length, subReaders2.length);
@@ -404,7 +404,7 @@
}
IndexReader reader3 = refreshReader(reader0, true).refreshedReader;
- assertTrue(reader3 instanceof MultiSegmentReader);
+ assertTrue(reader3 instanceof DirectoryReader);
IndexReader[] subReaders3 = reader3.getSequentialSubReaders();
assertEquals(subReaders3.length, subReaders0.length);
@@ -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();
}
@@ -1023,7 +1025,7 @@
}
if (checkSubReaders) {
- if (reader instanceof MultiSegmentReader) {
+ if (reader instanceof DirectoryReader) {
IndexReader[] subReaders = reader.getSequentialSubReaders();
for (int i = 0; i < subReaders.length; i++) {
assertReaderClosed(subReaders[i], checkSubReaders, checkNormsClosed);
@@ -1050,7 +1052,7 @@
private void assertReaderOpen(IndexReader reader) {
reader.ensureOpen();
- if (reader instanceof MultiSegmentReader) {
+ if (reader instanceof DirectoryReader) {
IndexReader[] subReaders = reader.getSequentialSubReaders();
for (int i = 0; i < subReaders.length; i++) {
assertReaderOpen(subReaders[i]);
@@ -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/TestMultiReader.java b/src/test/org/apache/lucene/index/TestMultiReader.java
--- a/src/test/org/apache/lucene/index/TestMultiReader.java
+++ b/src/test/org/apache/lucene/index/TestMultiReader.java
@@ -19,9 +19,7 @@
import java.io.IOException;
-import org.apache.lucene.store.Directory;
-
-public class TestMultiReader extends TestMultiSegmentReader {
+public class TestMultiReader extends TestDirectoryReader {
public TestMultiReader(String s) {
super(s);
}
diff --git a/src/test/org/apache/lucene/index/TestMultiSegmentReader.java b/src/test/org/apache/lucene/index/TestMultiSegmentReader.java
deleted file mode 100644
--- a/src/test/org/apache/lucene/index/TestMultiSegmentReader.java
+++ /dev/null
@@ -1,202 +0,0 @@
-package org.apache.lucene.index;
-
-/**
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import org.apache.lucene.util.LuceneTestCase;
-
-import org.apache.lucene.analysis.standard.StandardAnalyzer;
-import org.apache.lucene.document.Document;
-import org.apache.lucene.document.Field;
-import org.apache.lucene.store.Directory;
-import org.apache.lucene.store.RAMDirectory;
-
-import java.io.IOException;
-
-public class TestMultiSegmentReader extends LuceneTestCase {
- protected Directory dir;
- private Document doc1;
- private Document doc2;
- protected SegmentReader [] readers = new SegmentReader[2];
- protected SegmentInfos sis;
-
-
- public TestMultiSegmentReader(String s) {
- super(s);
- }
-
- protected void setUp() throws Exception {
- super.setUp();
- dir = new RAMDirectory();
- doc1 = new Document();
- doc2 = new Document();
- DocHelper.setupDoc(doc1);
- DocHelper.setupDoc(doc2);
- DocHelper.writeDoc(dir, doc1);
- DocHelper.writeDoc(dir, doc2);
- sis = new SegmentInfos();
- sis.read(dir);
- }
-
- protected IndexReader openReader() throws IOException {
- IndexReader reader;
- reader = IndexReader.open(dir);
- assertTrue(reader instanceof MultiSegmentReader);
-
- assertTrue(dir != null);
- assertTrue(sis != null);
- assertTrue(reader != null);
-
- return reader;
- }
-
- public void test() throws Exception {
- setUp();
- doTestDocument();
- doTestUndeleteAll();
- }
-
- public void doTestDocument() throws IOException {
- sis.read(dir);
- IndexReader reader = openReader();
- assertTrue(reader != null);
- Document newDoc1 = reader.document(0);
- assertTrue(newDoc1 != null);
- assertTrue(DocHelper.numFields(newDoc1) == DocHelper.numFields(doc1) - DocHelper.unstored.size());
- Document newDoc2 = reader.document(1);
- assertTrue(newDoc2 != null);
- assertTrue(DocHelper.numFields(newDoc2) == DocHelper.numFields(doc2) - DocHelper.unstored.size());
- TermFreqVector vector = reader.getTermFreqVector(0, DocHelper.TEXT_FIELD_2_KEY);
- assertTrue(vector != null);
- TestSegmentReader.checkNorms(reader);
- }
-
- public void doTestUndeleteAll() throws IOException {
- sis.read(dir);
- IndexReader reader = openReader();
- assertTrue(reader != null);
- assertEquals( 2, reader.numDocs() );
- reader.deleteDocument(0);
- assertEquals( 1, reader.numDocs() );
- reader.undeleteAll();
- assertEquals( 2, reader.numDocs() );
-
- // Ensure undeleteAll survives commit/close/reopen:
- reader.commit();
- reader.close();
-
- if (reader instanceof MultiReader)
- // MultiReader does not "own" the directory so it does
- // not write the changes to sis on commit:
- sis.commit(dir);
-
- sis.read(dir);
- reader = openReader();
- assertEquals( 2, reader.numDocs() );
-
- reader.deleteDocument(0);
- assertEquals( 1, reader.numDocs() );
- reader.commit();
- reader.close();
- if (reader instanceof MultiReader)
- // MultiReader does not "own" the directory so it does
- // not write the changes to sis on commit:
- sis.commit(dir);
- sis.read(dir);
- reader = openReader();
- assertEquals( 1, reader.numDocs() );
- }
-
-
- public void _testTermVectors() {
- MultiReader reader = new MultiReader(readers);
- assertTrue(reader != null);
- }
-
-
- public void testIsCurrent() throws IOException {
- RAMDirectory ramDir1=new RAMDirectory();
- addDoc(ramDir1, "test foo", true);
- RAMDirectory ramDir2=new RAMDirectory();
- addDoc(ramDir2, "test blah", true);
- IndexReader[] readers = new IndexReader[]{IndexReader.open(ramDir1), IndexReader.open(ramDir2)};
- MultiReader mr = new MultiReader(readers);
- assertTrue(mr.isCurrent()); // just opened, must be current
- addDoc(ramDir1, "more text", false);
- assertFalse(mr.isCurrent()); // has been modified, not current anymore
- addDoc(ramDir2, "even more text", false);
- assertFalse(mr.isCurrent()); // has been modified even more, not current anymore
- try {
- mr.getVersion();
- fail();
- } catch (UnsupportedOperationException e) {
- // expected exception
- }
- mr.close();
- }
-
- public void testMultiTermDocs() throws IOException {
- RAMDirectory ramDir1=new RAMDirectory();
- addDoc(ramDir1, "test foo", true);
- RAMDirectory ramDir2=new RAMDirectory();
- addDoc(ramDir2, "test blah", true);
- RAMDirectory ramDir3=new RAMDirectory();
- addDoc(ramDir3, "test wow", true);
-
- IndexReader[] readers1 = new IndexReader[]{IndexReader.open(ramDir1), IndexReader.open(ramDir3)};
- IndexReader[] readers2 = new IndexReader[]{IndexReader.open(ramDir1), IndexReader.open(ramDir2), IndexReader.open(ramDir3)};
- MultiReader mr2 = new MultiReader(readers1);
- MultiReader mr3 = new MultiReader(readers2);
-
- // test mixing up TermDocs and TermEnums from different readers.
- TermDocs td2 = mr2.termDocs();
- TermEnum te3 = mr3.terms(new Term("body","wow"));
- td2.seek(te3);
- int ret = 0;
-
- // This should blow up if we forget to check that the TermEnum is from the same
- // reader as the TermDocs.
- while (td2.next()) ret += td2.doc();
- td2.close();
- te3.close();
-
- // really a dummy assert to ensure that we got some docs and to ensure that
- // nothing is optimized out.
- assertTrue(ret > 0);
- }
-
- public void testAllTermDocs() throws IOException {
- IndexReader reader = openReader();
- int NUM_DOCS = 2;
- TermDocs td = reader.termDocs(null);
- for(int i=0;i