A FlushInfo provides information required for a FLUSH context and other optimization operations. + *
A FlushInfo provides information required for a FLUSH context. * It is used as part of an {@link IOContext} in case of FLUSH context.
*/ Index: lucene/src/java/org/apache/lucene/store/MergeInfo.java =================================================================== --- lucene/src/java/org/apache/lucene/store/MergeInfo.java (revision 1200448) +++ lucene/src/java/org/apache/lucene/store/MergeInfo.java (working copy) @@ -17,7 +17,7 @@ */ /** - *A MergeInfo provides information required for a MERGE context and other optimization operations. + *
A MergeInfo provides information required for a MERGE context. * It is used as part of an {@link IOContext} in case of MERGE context.
*/ @@ -29,7 +29,7 @@ public final boolean isExternal; - public final boolean optimize; + public final int mergeMaxNumSegments; /** @@ -40,11 +40,11 @@ * */ - public MergeInfo(int totalDocCount, long estimatedMergeBytes, boolean isExternal, boolean optimize) { + public MergeInfo(int totalDocCount, long estimatedMergeBytes, boolean isExternal, int mergeMaxNumSegments) { this.totalDocCount = totalDocCount; this.estimatedMergeBytes = estimatedMergeBytes; this.isExternal = isExternal; - this.optimize = optimize; + this.mergeMaxNumSegments = mergeMaxNumSegments; } @@ -55,7 +55,7 @@ result = prime * result + (int) (estimatedMergeBytes ^ (estimatedMergeBytes >>> 32)); result = prime * result + (isExternal ? 1231 : 1237); - result = prime * result + (optimize ? 1231 : 1237); + result = prime * result + mergeMaxNumSegments; result = prime * result + totalDocCount; return result; } @@ -73,7 +73,7 @@ return false; if (isExternal != other.isExternal) return false; - if (optimize != other.optimize) + if (mergeMaxNumSegments != other.mergeMaxNumSegments) return false; if (totalDocCount != other.totalDocCount) return false; @@ -84,6 +84,6 @@ public String toString() { return "MergeInfo [totalDocCount=" + totalDocCount + ", estimatedMergeBytes=" + estimatedMergeBytes + ", isExternal=" - + isExternal + ", optimize=" + optimize + "]"; + + isExternal + ", mergeMaxNumSegments=" + mergeMaxNumSegments + "]"; } -} \ No newline at end of file +} Index: lucene/src/java/org/apache/lucene/search/MultiTermQuery.java =================================================================== --- lucene/src/java/org/apache/lucene/search/MultiTermQuery.java (revision 1200448) +++ lucene/src/java/org/apache/lucene/search/MultiTermQuery.java (working copy) @@ -273,14 +273,14 @@ /** * Expert: Return the number of unique terms visited during execution of the query. * If there are many of them, you may consider using another query type - * or optimize your total term count in index. + * or reduce your total term count in index. *This method is not thread safe, be sure to only call it when no query is running! * If you re-use the same query instance for another * search, be sure to first reset the term counter * with {@link #clearTotalNumberOfTerms}. - *
On optimized indexes / no MultiReaders, you get the correct number of + *
On single-segment indexes / no MultiReaders, you get the correct number of * unique terms for the whole index. Use this number to compare different queries. - * For non-optimized indexes this number can also be achieved in + * For multi-segment indexes this number can also be achieved in * non-constant-score mode. In constant-score mode you get the total number of * terms seeked for all segments / sub-readers. * @see #clearTotalNumberOfTerms Index: lucene/src/java/org/apache/lucene/index/UpgradeIndexMergePolicy.java =================================================================== --- lucene/src/java/org/apache/lucene/index/UpgradeIndexMergePolicy.java (revision 1200448) +++ lucene/src/java/org/apache/lucene/index/UpgradeIndexMergePolicy.java (working copy) @@ -27,24 +27,24 @@ import java.util.HashMap; /** This {@link MergePolicy} is used for upgrading all existing segments of - * an index when calling {@link IndexWriter#optimize()}. + * an index when calling {@link IndexWriter#forceMerge(int)}. * All other methods delegate to the base {@code MergePolicy} given to the constructor. * This allows for an as-cheap-as possible upgrade of an older index by only upgrading segments that - * are created by previous Lucene versions. Optimize does no longer really optimize - * it is just used to "optimize" older segment versions away. + * are created by previous Lucene versions. forceMerge does no longer really merge; + * it is just used to "forceMerge" older segment versions away. *
In general one would use {@link IndexUpgrader}, but for a fully customizeable upgrade, - * you can use this like any other {@code MergePolicy} and call {@link IndexWriter#optimize()}: + * you can use this like any other {@code MergePolicy} and call {@link IndexWriter#forceMerge(int)}: *
* IndexWriterConfig iwc = new IndexWriterConfig(Version.LUCENE_XX, new KeywordAnalyzer()); * iwc.setMergePolicy(new UpgradeIndexMergePolicy(iwc.getMergePolicy())); * IndexWriter w = new IndexWriter(dir, iwc); - * w.optimize(); + * w.forceMerge(1); * w.close(); **
Warning: This merge policy may reorder documents if the index was partially
- * upgraded before calling optimize (e.g., documents were added). If your application relies
+ * upgraded before calling forceMerge (e.g., documents were added). If your application relies
* on "monotonicity" of doc IDs (which means that the order in which the documents
- * were added to the index is preserved), do a full optimize instead. Please note, the
+ * were added to the index is preserved), do a forceMerge(1) instead. Please note, the
* delegate {@code MergePolicy} may also reorder documents.
* @lucene.experimental
* @see IndexUpgrader
@@ -53,7 +53,7 @@
protected final MergePolicy base;
- /** Wrap the given {@link MergePolicy} and intercept optimize requests to
+ /** Wrap the given {@link MergePolicy} and intercept forceMerge requests to
* only upgrade segments written with previous Lucene versions. */
public UpgradeIndexMergePolicy(MergePolicy base) {
this.base = base;
@@ -80,22 +80,22 @@
}
@Override
- public MergeSpecification findMergesForOptimize(SegmentInfos segmentInfos, int maxSegmentCount, Map Expert: a MergePolicy determines the sequence of
- * primitive merge operations to be used for overall merge
- * and optimize operations.
Whenever the segments in an index have been altered by * {@link IndexWriter}, either the addition of a newly @@ -42,8 +41,8 @@ * merges that are now required. This method returns a * {@link MergeSpecification} instance describing the set of * merges that should be done, or null if no merges are - * necessary. When IndexWriter.optimize is called, it calls - * {@link #findMergesForOptimize} and the MergePolicy should + * necessary. When IndexWriter.forceMerge is called, it calls + * {@link #findForcedMerges(SegmentInfos,int,Map)} and the MergePolicy should * then return the necessary merges.
* *Note that the policy can return more than one merge at
@@ -69,11 +68,10 @@
public static class OneMerge {
SegmentInfo info; // used by IndexWriter
- boolean optimize; // used by IndexWriter
boolean registerDone; // used by IndexWriter
long mergeGen; // used by IndexWriter
boolean isExternal; // used by IndexWriter
- int maxNumSegmentsOptimize; // used by IndexWriter
+ int maxNumSegments = -1; // used by IndexWriter
public long estimatedMergeBytes; // used by IndexWriter
List NOTE: This policy always merges by byte size
* of the segments, always pro-rates by percent deletes,
* and does not apply any maximum segment size during
- * optimize (unlike {@link LogByteSizeMergePolicy}).
+ * forceMerge (unlike {@link LogByteSizeMergePolicy}).
*
* @lucene.experimental
*/
@@ -88,7 +88,7 @@
/** Maximum number of segments to be merged at a time
* during "normal" merging. For explicit merging (eg,
- * optimize or expungeDeletes was called), see {@link
+ * forceMerge or expungeDeletes was called), see {@link
* #setMaxMergeAtOnceExplicit}. Default is 10. */
public TieredMergePolicy setMaxMergeAtOnce(int v) {
if (v < 2) {
@@ -107,7 +107,7 @@
// if user calls IW.maybeMerge "explicitly"
/** Maximum number of segments to be merged at a time,
- * during optimize or expungeDeletes. Default is 30. */
+ * during forceMerge or expungeDeletes. Default is 30. */
public TieredMergePolicy setMaxMergeAtOnceExplicit(int v) {
if (v < 2) {
throw new IllegalArgumentException("maxMergeAtOnceExplicit must be > 1 (got " + v + ")");
@@ -478,23 +478,23 @@
}
@Override
- public MergeSpecification findMergesForOptimize(SegmentInfos infos, int maxSegmentCount, Map If an index will not have more documents added for a while and optimal search
- performance is desired, then either the full {@link #optimize() optimize}
- method or partial {@link #optimize(int)} method should be
- called before the index is closed. Opening an Optimize is a very costly operation, so you
- * should only do it if your search performance really
- * requires it. Many search applications do fine never
- * calling optimize. This is a horribly costly operation, especially when
+ * you pass a small {@code maxNumSegments}; usually you
+ * should only call this if the index is static (will no
+ * longer be changed). Note that optimize requires 2X the index size free
+ * Note that this requires up to 2X the index size free
* space in your Directory (3X if you're using compound
* file format). For example, if your index size is 10 MB
- * then you need 20 MB free for optimize to complete (30
+ * then you need up to 20 MB free for this to complete (30
* MB if you're using compound file format). Also,
- * it's best to call {@link #commit()} after the optimize
- * completes to allow IndexWriter to free up disk space.IndexWriter creates a lock file for the directory in use. Trying to open
another IndexWriter on the same directory will lead to a
{@link LockObtainFailedException}. The {@link LockObtainFailedException}
@@ -134,9 +129,8 @@
The {@link MergePolicy} is invoked whenever there are
changes to the segments in the index. Its role is to
select which merges to do, if any, and return a {@link
- MergePolicy.MergeSpecification} describing the merges. It
- also selects merges to do for optimize(). (The default is
- {@link LogByteSizeMergePolicy}. Then, the {@link
+ MergePolicy.MergeSpecification} describing the merges.
+ The default is {@link LogByteSizeMergePolicy}. Then, the {@link
MergeScheduler} is invoked with the requested merges and
it decides when and how to run the merges. The default is
{@link ConcurrentMergeScheduler}.
If some but not all readers re-open while an - * optimize is underway, this will cause > 2X temporary + *
If some but not all readers re-open while merging + * is underway, this will cause > 2X temporary * space to be consumed as those new readers will then - * hold open the partially optimized segments at that - * time. It is best not to re-open readers while optimize - * is running.
+ * hold open the temporary segments at that time. It is + * best not to re-open readers while merging is running. * *The actual temporary usage could be much less than * these figures (it depends on many factors).
* - *In general, once the optimize completes, the total size of the + *
In general, once the this completes, the total size of the * index will be less than the size of the starting index. * It could be quite a bit smaller (if there were many * pending deletes) or just slightly smaller.
* - *If an Exception is hit during optimize(), for example + *
If an Exception is hit, for example * due to disk full, the index will not be corrupt and no * documents will have been lost. However, it may have - * been partially optimized (some segments were merged but + * been partially merged (some segments were merged but * not all), and it's possible that one of the segments in * the index will be in non-compound format even when * using compound file format. This will occur when the * Exception is hit during conversion of the segment into * compound format.
* - *This call will optimize those segments present in + *
This call will merge those segments present in * the index when the call started. If other threads are * still adding documents and flushing segments, those - * newly created segments will not be optimized unless you - * call optimize again.
+ * newly created segments will not be merged unless you + * call forceMerge again. * *NOTE: if this method hits an OutOfMemoryError * you should immediately close the writer. See NOTE: if this method hits an OutOfMemoryError - * you should immediately close the writer. See above for details.
- * * @param maxNumSegments maximum number of segments left - * in the index after optimization finishes - */ - public void optimize(int maxNumSegments) throws CorruptIndexException, IOException { - optimize(maxNumSegments, true); + * in the index after merging finishes + */ + public void forceMerge(int maxNumSegments) throws CorruptIndexException, IOException { + forceMerge(maxNumSegments, true); } - /** Just like {@link #optimize()}, except you can specify - * whether the call should block until the optimize - * completes. This is only meaningful with a + /** Just like {@link #forceMerge(int)}, except you can + * specify whether the call should block until + * all merging completes. This is only meaningful with a * {@link MergeScheduler} that is able to run merges in * background threads. * - *NOTE: if this method hits an OutOfMemoryError - * you should immediately close the writer. See above for details.
+ *NOTE: if this method hits an OutOfMemoryError + * you should immediately close the writer. See above for details.
*/ - public void optimize(boolean doWait) throws CorruptIndexException, IOException { - optimize(1, doWait); - } - - /** Just like {@link #optimize(int)}, except you can - * specify whether the call should block until the - * optimize completes. This is only meaningful with a - * {@link MergeScheduler} that is able to run merges in - * background threads. - * - *NOTE: if this method hits an OutOfMemoryError - * you should immediately close the writer. See above for details.
- */ - public void optimize(int maxNumSegments, boolean doWait) throws CorruptIndexException, IOException { + public void forceMerge(int maxNumSegments, boolean doWait) throws CorruptIndexException, IOException { ensureOpen(); if (maxNumSegments < 1) throw new IllegalArgumentException("maxNumSegments must be >= 1; got " + maxNumSegments); if (infoStream != null) { - infoStream.message("IW", "optimize: index now " + segString()); - infoStream.message("IW", "now flush at optimize"); + infoStream.message("IW", "forceMerge: index now " + segString()); + infoStream.message("IW", "now flush at forceMerge"); } flush(true, true); synchronized(this) { resetMergeExceptions(); - segmentsToOptimize.clear(); + segmentsToMerge.clear(); for(SegmentInfo info : segmentInfos) { - segmentsToOptimize.put(info, Boolean.TRUE); + segmentsToMerge.put(info, Boolean.TRUE); } - optimizeMaxNumSegments = maxNumSegments; + mergeMaxNumSegments = maxNumSegments; - // Now mark all pending & running merges as optimize - // merge: + // Now mark all pending & running merges as isMaxNumSegments: for(final MergePolicy.OneMerge merge : pendingMerges) { - merge.optimize = true; - merge.maxNumSegmentsOptimize = maxNumSegments; - segmentsToOptimize.put(merge.info, Boolean.TRUE); + merge.maxNumSegments = maxNumSegments; + segmentsToMerge.put(merge.info, Boolean.TRUE); } for ( final MergePolicy.OneMerge merge: runningMerges ) { - merge.optimize = true; - merge.maxNumSegmentsOptimize = maxNumSegments; - segmentsToOptimize.put(merge.info, Boolean.TRUE); + merge.maxNumSegments = maxNumSegments; + segmentsToMerge.put(merge.info, Boolean.TRUE); } } - maybeMerge(maxNumSegments, true); + maybeMerge(maxNumSegments); if (doWait) { synchronized(this) { while(true) { if (hitOOM) { - throw new IllegalStateException("this writer hit an OutOfMemoryError; cannot complete optimize"); + throw new IllegalStateException("this writer hit an OutOfMemoryError; cannot complete forceMerge"); } if (mergeExceptions.size() > 0) { @@ -1724,7 +1686,7 @@ final int size = mergeExceptions.size(); for(int i=0;i* NOTE: this method only copies the segments of the incoming indexes @@ -2452,7 +2409,7 @@ && versionComparator.compare(info.getVersion(), "3.1") >= 0; } - IOContext context = new IOContext(new MergeInfo(info.docCount, info.sizeInBytes(true), true, false)); + IOContext context = new IOContext(new MergeInfo(info.docCount, info.sizeInBytes(true), true, -1)); if (createCFS) { copySegmentIntoCFS(info, newSegName, context); @@ -2476,7 +2433,6 @@ } /** Merges the provided indexes into this index. - *
After this completes, the index is optimized.
*The provided IndexReaders are not closed.
* *NOTE: while this is running, any attempts to @@ -2512,7 +2468,7 @@ for (IndexReader indexReader : readers) { numDocs += indexReader.numDocs(); } - final IOContext context = new IOContext(new MergeInfo(numDocs, -1, true, false)); + final IOContext context = new IOContext(new MergeInfo(numDocs, -1, true, -1)); // TODO: somehow we should fix this merge so it's // abortable so that IW.close(false) is able to stop it @@ -2789,7 +2745,7 @@ /** *
Commits all pending changes (added & deleted
- * documents, optimizations, segment merges, added
+ * documents, segment merges, added
* indexes, etc.) to the index, and syncs all referenced
* index files, such that a reader will see the changes
* and the index updates will survive an OS or machine
@@ -3199,10 +3155,10 @@
// disk, updating SegmentInfo, etc.:
readerPool.clear(merge.segments);
- if (merge.optimize) {
- // cascade the optimize:
- if (!segmentsToOptimize.containsKey(merge.info)) {
- segmentsToOptimize.put(merge.info, Boolean.FALSE);
+ if (merge.maxNumSegments != -1) {
+ // cascade the forceMerge:
+ if (!segmentsToMerge.containsKey(merge.info)) {
+ segmentsToMerge.put(merge.info, Boolean.FALSE);
}
}
@@ -3216,7 +3172,7 @@
}
// Set the exception on the merge, so if
- // optimize() is waiting on us it sees the root
+ // forceMerge is waiting on us it sees the root
// cause exception:
merge.setException(t);
addMergeException(merge);
@@ -3283,8 +3239,8 @@
// This merge (and, generally, any change to the
// segments) may now enable new merges, so we call
// merge policy & update pending merges.
- if (success && !merge.isAborted() && (merge.optimize || (!closed && !closing))) {
- updatePendingMerges(merge.maxNumSegmentsOptimize, merge.optimize);
+ if (success && !merge.isAborted() && (merge.maxNumSegments != -1 || (!closed && !closing))) {
+ updatePendingMerges(merge.maxNumSegments);
}
}
}
@@ -3328,9 +3284,8 @@
if (info.dir != directory) {
isExternal = true;
}
- if (segmentsToOptimize.containsKey(info)) {
- merge.optimize = true;
- merge.maxNumSegmentsOptimize = optimizeMaxNumSegments;
+ if (segmentsToMerge.containsKey(info)) {
+ merge.maxNumSegments = mergeMaxNumSegments;
}
}
@@ -3393,7 +3348,7 @@
assert testPoint("startMergeInit");
assert merge.registerDone;
- assert !merge.optimize || merge.maxNumSegmentsOptimize > 0;
+ assert merge.maxNumSegments == -1 || merge.maxNumSegments > 0;
if (hitOOM) {
throw new IllegalStateException("this writer hit an OutOfMemoryError; cannot merge");
@@ -3443,7 +3398,7 @@
// Lock order: IW -> BD
bufferedDeletesStream.prune(segmentInfos);
Map This tool keeps only the last commit in an index; for this
* reason, if the incoming index has more than one commit, the tool
* refuses to run by default. Specify {@code -delete-prior-commits}
@@ -45,7 +45,7 @@
* Warning: This tool may reorder documents if the index was partially
* upgraded before execution (e.g., documents were added). If your application relies
* on "monotonicity" of doc IDs (which means that the order in which the documents
- * were added to the index is preserved), do a full optimize instead.
+ * were added to the index is preserved), do a full forceMerge instead.
* The {@link MergePolicy} set by {@link IndexWriterConfig} may also reorder
* documents.
*/
@@ -134,7 +134,7 @@
if (infoStream != null) {
infoStream.message("IndexUpgrader", "Upgrading all pre-" + Constants.LUCENE_MAIN_VERSION + " segments of index directory '" + dir + "' to version " + Constants.LUCENE_MAIN_VERSION + "...");
}
- w.optimize();
+ w.forceMerge(1);
if (infoStream != null) {
infoStream.message("IndexUpgrader", "All segments upgraded to version " + Constants.LUCENE_MAIN_VERSION);
}
Index: lucene/src/java/org/apache/lucene/index/ParallelReader.java
===================================================================
--- lucene/src/java/org/apache/lucene/index/ParallelReader.java (revision 1200448)
+++ lucene/src/java/org/apache/lucene/index/ParallelReader.java (working copy)
@@ -477,23 +477,6 @@
return true;
}
- /**
- * Checks recursively if all subindexes are optimized
- */
- @Override
- public boolean isOptimized() {
- ensureOpen();
- for (final IndexReader reader : readers) {
- if (!reader.isOptimized()) {
- return false;
- }
- }
-
- // all subindexes are optimized
- return true;
- }
-
-
/** Not implemented.
* @throws UnsupportedOperationException
*/
Index: lucene/src/java/org/apache/lucene/index/DirectoryReader.java
===================================================================
--- lucene/src/java/org/apache/lucene/index/DirectoryReader.java (revision 1200448)
+++ lucene/src/java/org/apache/lucene/index/DirectoryReader.java (working copy)
@@ -523,17 +523,7 @@
subReaders[i].getTermFreqVector(docNumber - starts[i], mapper);
}
- /**
- * Checks is the index is optimized (if it has a single segment and no deletions)
- * @return Determines the largest segment (measured by total
* byte size of the segment's files, in MB) that may be
- * merged with other segments during optimize. Setting
+ * merged with other segments during forceMerge. Setting
* it low will leave the index with more than 1 segment,
- * even if {@link IndexWriter#optimize()} is called.*/
- public void setMaxMergeMBForOptimize(double mb) {
- maxMergeSizeForOptimize = (long) (mb*1024*1024);
+ * even if {@link IndexWriter#forceMerge} is called.*/
+ public void setMaxMergeMBForForcedMerge(double mb) {
+ maxMergeSizeForForcedMerge = (long) (mb*1024*1024);
}
/** Returns the largest segment (measured by total byte
* size of the segment's files, in MB) that may be merged
- * with other segments during optimize.
- * @see #setMaxMergeMBForOptimize */
- public double getMaxMergeMBForOptimize() {
- return ((double) maxMergeSizeForOptimize)/1024/1024;
+ * with other segments during forceMerge.
+ * @see #setMaxMergeMBForForcedMerge */
+ public double getMaxMergeMBForForcedMerge() {
+ return ((double) maxMergeSizeForForcedMerge)/1024/1024;
}
/** Sets the minimum size for the lowest level segments.
Index: lucene/src/java/org/apache/lucene/index/IndexReader.java
===================================================================
--- lucene/src/java/org/apache/lucene/index/IndexReader.java (revision 1200448)
+++ lucene/src/java/org/apache/lucene/index/IndexReader.java (working copy)
@@ -28,7 +28,6 @@
import org.apache.lucene.document.Document;
import org.apache.lucene.document.DocumentStoredFieldVisitor;
-import org.apache.lucene.index.codecs.PostingsFormat;
import org.apache.lucene.index.codecs.PerDocValues;
import org.apache.lucene.index.values.IndexDocValues;
import org.apache.lucene.search.FieldCache; // javadocs
@@ -805,16 +804,6 @@
}
/**
- * Checks is the index is optimized (if it has a single segment and
- * no deletions). Not implemented in the IndexReader base class.
- * @return Only takes effect when IndexWriter is first created. */
Index: lucene/src/test-framework/java/org/apache/lucene/analysis/CollationTestBase.java
===================================================================
--- lucene/src/test-framework/java/org/apache/lucene/analysis/CollationTestBase.java (revision 1200448)
+++ lucene/src/test-framework/java/org/apache/lucene/analysis/CollationTestBase.java (working copy)
@@ -216,7 +216,7 @@
doc.add(new TextField("Denmark", denmarkAnalyzer.tokenStream("Denmark", new StringReader(sortData[i][5]))));
writer.addDocument(doc);
}
- writer.optimize();
+ writer.forceMerge(1);
writer.close();
IndexSearcher searcher = new IndexSearcher(indexStore, true);
Index: lucene/src/test-framework/java/org/apache/lucene/index/RandomIndexWriter.java
===================================================================
--- lucene/src/test-framework/java/org/apache/lucene/index/RandomIndexWriter.java (revision 1200448)
+++ lucene/src/test-framework/java/org/apache/lucene/index/RandomIndexWriter.java (working copy)
@@ -38,7 +38,7 @@
/** Silly class that randomizes the indexing experience. EG
* it may swap in a different merge policy/scheduler; may
- * commit periodically; may or may not optimize in the end,
+ * commit periodically; may or may not forceMerge in the end,
* may flush by doc count instead of RAM, etc.
*/
@@ -323,8 +323,8 @@
return getReader(true);
}
- private boolean doRandomOptimize = true;
- private boolean doRandomOptimizeAssert = true;
+ private boolean doRandomForceMerge = true;
+ private boolean doRandomForceMergeAssert = true;
public void expungeDeletes(boolean doWait) throws IOException {
w.expungeDeletes(doWait);
@@ -334,25 +334,25 @@
w.expungeDeletes();
}
- public void setDoRandomOptimize(boolean v) {
- doRandomOptimize = v;
+ public void setDoRandomForceMerge(boolean v) {
+ doRandomForceMerge = v;
}
- public void setDoRandomOptimizeAssert(boolean v) {
- doRandomOptimizeAssert = v;
+ public void setDoRandomForceMergeAssert(boolean v) {
+ doRandomForceMergeAssert = v;
}
- private void doRandomOptimize() throws IOException {
- if (doRandomOptimize) {
+ private void doRandomForceMerge() throws IOException {
+ if (doRandomForceMerge) {
final int segCount = w.getSegmentCount();
if (r.nextBoolean() || segCount == 0) {
- // full optimize
- w.optimize();
+ // full forceMerge
+ w.forceMerge(1);
} else {
- // partial optimize
+ // partial forceMerge
final int limit = _TestUtil.nextInt(r, 1, segCount);
- w.optimize(limit);
- assert !doRandomOptimizeAssert || w.getSegmentCount() <= limit: "limit=" + limit + " actual=" + w.getSegmentCount();
+ w.forceMerge(limit);
+ assert !doRandomForceMergeAssert || w.getSegmentCount() <= limit: "limit=" + limit + " actual=" + w.getSegmentCount();
}
}
switchDoDocValues();
@@ -361,7 +361,7 @@
public IndexReader getReader(boolean applyDeletions) throws IOException {
getReaderCalled = true;
if (r.nextInt(4) == 2) {
- doRandomOptimize();
+ doRandomForceMerge();
}
// If we are writing with PreFlexRW, force a full
// IndexReader.open so terms are sorted in codepoint
@@ -394,21 +394,21 @@
*/
public void close() throws IOException {
// if someone isn't using getReader() API, we want to be sure to
- // maybeOptimize since presumably they might open a reader on the dir.
+ // forceMerge since presumably they might open a reader on the dir.
if (getReaderCalled == false && r.nextInt(8) == 2) {
- doRandomOptimize();
+ doRandomForceMerge();
}
w.close();
}
/**
- * Forces an optimize.
+ * Forces a forceMerge.
*
* NOTE: this should be avoided in tests unless absolutely necessary,
* as it will result in less test coverage.
- * @see IndexWriter#optimize()
+ * @see IndexWriter#forceMerge(int)
*/
- public void optimize() throws IOException {
- w.optimize();
+ public void forceMerge(int maxSegmentCount) throws IOException {
+ w.forceMerge(maxSegmentCount);
}
}
Index: lucene/src/test-framework/java/org/apache/lucene/index/ThreadedIndexingAndSearchingTestCase.java
===================================================================
--- lucene/src/test-framework/java/org/apache/lucene/index/ThreadedIndexingAndSearchingTestCase.java (revision 1200448)
+++ lucene/src/test-framework/java/org/apache/lucene/index/ThreadedIndexingAndSearchingTestCase.java (working copy)
@@ -54,7 +54,7 @@
import org.apache.lucene.util._TestUtil;
// TODO
-// - mix in optimize, addIndexes
+// - mix in forceMerge, addIndexes
// - randomly mix in non-congruent docs
/** Utility class that spawns multiple indexing and
Index: lucene/src/test-framework/java/org/apache/lucene/index/MockRandomMergePolicy.java
===================================================================
--- lucene/src/test-framework/java/org/apache/lucene/index/MockRandomMergePolicy.java (revision 1200448)
+++ lucene/src/test-framework/java/org/apache/lucene/index/MockRandomMergePolicy.java (working copy)
@@ -55,18 +55,18 @@
}
@Override
- public MergeSpecification findMergesForOptimize(
- SegmentInfos segmentInfos, int maxSegmentCount, Map This tool does file-level copying of segments files.
* This means it's unable to split apart a single segment
- * into multiple segments. For example if your index is
- * optimized, this tool won't help. Also, it does basic
+ * into multiple segments. For example if your index is a
+ * single segment, this tool won't help. Also, it does basic
* file-level copying (using simple
* File{In,Out}putStream) so it will not work with non
* FSDirectory Directory impls.true if the index is optimized; false otherwise
- */
@Override
- public boolean isOptimized() {
- ensureOpen();
- return segmentInfos.size() == 1 && !hasDeletions();
- }
-
- @Override
public int numDocs() {
// Don't call ensureOpen() here (it could affect performance)
@@ -953,8 +943,8 @@
Directory dir;
long generation;
long version;
- final boolean isOptimized;
final Maptrue if the index is optimized; false otherwise
- * @throws UnsupportedOperationException unless overridden in subclass
- */
- public boolean isOptimized() {
- throw new UnsupportedOperationException("This reader does not support this method.");
- }
-
- /**
* Return an array of term frequency vectors for the specified document.
* The array contains a vector for each vectorized field in the document.
* Each vector contains terms and frequencies for all terms in a given vectorized field.
Index: lucene/src/java/org/apache/lucene/index/IndexFileDeleter.java
===================================================================
--- lucene/src/java/org/apache/lucene/index/IndexFileDeleter.java (revision 1200448)
+++ lucene/src/java/org/apache/lucene/index/IndexFileDeleter.java (working copy)
@@ -19,11 +19,9 @@
import java.io.FileNotFoundException;
import java.io.IOException;
-import java.io.PrintStream;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
-import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@@ -653,8 +651,8 @@
Collection