You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucene.apache.org by mi...@apache.org on 2011/11/12 15:09:33 UTC
svn commit: r1201265 [2/4] - in /lucene/dev/branches/branch_3x: ./ lucene/
lucene/backwards/src/test-framework/org/apache/lucene/index/
lucene/backwards/src/test/org/apache/lucene/index/
lucene/contrib/benchmark/conf/ lucene/contrib/benchmark/src/java/...
Modified: lucene/dev/branches/branch_3x/lucene/src/java/org/apache/lucene/index/IndexWriter.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/branch_3x/lucene/src/java/org/apache/lucene/index/IndexWriter.java?rev=1201265&r1=1201264&r2=1201265&view=diff
==============================================================================
--- lucene/dev/branches/branch_3x/lucene/src/java/org/apache/lucene/index/IndexWriter.java (original)
+++ lucene/dev/branches/branch_3x/lucene/src/java/org/apache/lucene/index/IndexWriter.java Sat Nov 12 14:09:28 2011
@@ -95,11 +95,6 @@ import org.apache.lucene.util.TwoPhaseCo
addDocument calls (see <a href="#mergePolicy">below</a>
for changing the {@link MergeScheduler}).</p>
- <p>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.</p>
-
<p>Opening an <code>IndexWriter</code> creates a lock file for the directory in use. Trying to open
another <code>IndexWriter</code> on the same directory will lead to a
{@link LockObtainFailedException}. The {@link LockObtainFailedException}
@@ -128,9 +123,8 @@ import org.apache.lucene.util.TwoPhaseCo
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}. </p>
@@ -287,8 +281,9 @@ public class IndexWriter implements Clos
private DocumentsWriter docWriter;
private IndexFileDeleter deleter;
- private Map<SegmentInfo,Boolean> segmentsToOptimize = new HashMap<SegmentInfo,Boolean>(); // used by optimize to note those needing optimization
- private int optimizeMaxNumSegments;
+ // used by forceMerge to note those needing merging
+ private Map<SegmentInfo,Boolean> segmentsToMerge = new HashMap<SegmentInfo,Boolean>();
+ private int mergeMaxNumSegments;
private Lock writeLock;
@@ -2020,7 +2015,7 @@ public class IndexWriter implements Clos
* readers/searchers are open against the index, and up to
* 2X the size of all segments being merged when
* readers/searchers are open against the index (see
- * {@link #optimize()} for details). The sequence of
+ * {@link #forceMerge(int)} for details). The sequence of
* primitive merge operations performed is governed by the
* merge policy.
*
@@ -2392,56 +2387,89 @@ public class IndexWriter implements Clos
private PrintStream infoStream;
private static PrintStream defaultInfoStream;
+ /** This method has been deprecated, as it is horribly
+ * inefficient and very rarely justified. Lucene's
+ * multi-segment search performance has improved over
+ * time, and the default TieredMergePolicy now targets
+ * segments with deletions.
+ *
+ * @deprecated */
+ @Deprecated
+ public void optimize() throws CorruptIndexException, IOException {
+ forceMerge(1, true);
+ }
+
+ /** This method has been deprecated, as it is horribly
+ * inefficient and very rarely justified. Lucene's
+ * multi-segment search performance has improved over
+ * time, and the default TieredMergePolicy now targets
+ * segments with deletions.
+ *
+ * @deprecated */
+ @Deprecated
+ public void optimize(int maxNumSegments) throws CorruptIndexException, IOException {
+ forceMerge(maxNumSegments, true);
+ }
+
+ /** This method has been deprecated, as it is horribly
+ * inefficient and very rarely justified. Lucene's
+ * multi-segment search performance has improved over
+ * time, and the default TieredMergePolicy now targets
+ * segments with deletions.
+ *
+ * @deprecated */
+ @Deprecated
+ public void optimize(boolean doWait) throws CorruptIndexException, IOException {
+ forceMerge(1, doWait);
+ }
+
/**
- * Requests an "optimize" operation on an index, priming the index
- * for the fastest available search. Traditionally this has meant
- * merging all segments into a single segment as is done in the
- * default merge policy, but individual merge policies may implement
- * optimize in different ways.
- *
- * <p> 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. </p>
+ * Forces merge policy to merge segments until there's <=
+ * maxNumSegments. The actual merges to be
+ * executed are determined by the {@link MergePolicy}.
+ *
+ * <p>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).</p>
*
- * <p>Note that optimize requires 2X the index size free
+ * <p>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.</p>
+ * it's best to call {@link #commit()} afterwards,
+ * to allow IndexWriter to free up disk space.</p>
*
- * <p>If some but not all readers re-open while an
- * optimize is underway, this will cause > 2X temporary
+ * <p>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.</p>
+ * hold open the temporary segments at that time. It is
+ * best not to re-open readers while merging is running.</p>
*
* <p>The actual temporary usage could be much less than
* these figures (it depends on many factors).</p>
*
- * <p>In general, once the optimize completes, the total size of the
+ * <p>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.</p>
*
- * <p>If an Exception is hit during optimize(), for example
+ * <p>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.</p>
*
- * <p>This call will optimize those segments present in
+ * <p>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.</p>
+ * newly created segments will not be merged unless you
+ * call forceMerge again.</p>
*
* <p><b>NOTE</b>: if this method hits an OutOfMemoryError
* you should immediately close the writer. See <a
@@ -2454,96 +2482,66 @@ public class IndexWriter implements Clos
*
* @throws CorruptIndexException if the index is corrupt
* @throws IOException if there is a low-level IO error
- * @see MergePolicy#findMergesForOptimize
- */
- public void optimize() throws CorruptIndexException, IOException {
- optimize(true);
- }
-
- /**
- * Optimize the index down to <= maxNumSegments. If
- * maxNumSegments==1 then this is the same as {@link
- * #optimize()}.
- *
- * <p><b>NOTE</b>: if this method hits an OutOfMemoryError
- * you should immediately close the writer. See <a
- * href="#OOME">above</a> for details.</p>
+ * @see MergePolicy#findMerges
*
* @param maxNumSegments maximum number of segments left
- * in the index after optimization finishes
- */
- public void optimize(int maxNumSegments) throws CorruptIndexException, IOException {
- optimize(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
- * {@link MergeScheduler} that is able to run merges in
- * background threads.
- *
- * <p><b>NOTE</b>: if this method hits an OutOfMemoryError
- * you should immediately close the writer. See <a
- * href="#OOME">above</a> for details.</p>
- */
- public void optimize(boolean doWait) throws CorruptIndexException, IOException {
- optimize(1, doWait);
+ * in the index after merging finishes
+ */
+ public void forceMerge(int maxNumSegments) throws CorruptIndexException, IOException {
+ forceMerge(maxNumSegments, true);
}
- /** Just like {@link #optimize(int)}, 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.
*
- * <p><b>NOTE</b>: if this method hits an OutOfMemoryError
- * you should immediately close the writer. See <a
- * href="#OOME">above</a> for details.</p>
+ * <p><b>NOTE</b>: if this method hits an OutOfMemoryError
+ * you should immediately close the writer. See <a
+ * href="#OOME">above</a> for details.</p>
*/
- 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) {
- message("optimize: index now " + segString());
- message("now flush at optimize");
+ message("forceMerge: index now " + segString());
+ message("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) {
@@ -2552,7 +2550,7 @@ public class IndexWriter implements Clos
final int size = mergeExceptions.size();
for(int i=0;i<size;i++) {
final MergePolicy.OneMerge merge = mergeExceptions.get(i);
- if (merge.optimize) {
+ if (merge.maxNumSegments != -1) {
IOException err = new IOException("background merge hit exception: " + merge.segString(directory));
final Throwable t = merge.getException();
if (t != null)
@@ -2562,7 +2560,7 @@ public class IndexWriter implements Clos
}
}
- if (optimizeMergesPending())
+ if (maxNumSegmentsMergesPending())
doWait();
else
break;
@@ -2571,26 +2569,26 @@ public class IndexWriter implements Clos
// If close is called while we are still
// running, throw an exception so the calling
- // thread will know the optimize did not
+ // thread will know merging did not
// complete
ensureOpen();
}
// NOTE: in the ConcurrentMergeScheduler case, when
// doWait is false, we can return immediately while
- // background threads accomplish the optimization
+ // background threads accomplish the merging
}
/** Returns true if any merges in pendingMerges or
- * runningMerges are optimization merges. */
- private synchronized boolean optimizeMergesPending() {
+ * runningMerges are maxNumSegments merges. */
+ private synchronized boolean maxNumSegmentsMergesPending() {
for (final MergePolicy.OneMerge merge : pendingMerges) {
- if (merge.optimize)
+ if (merge.maxNumSegments != -1)
return true;
}
for (final MergePolicy.OneMerge merge : runningMerges) {
- if (merge.optimize)
+ if (merge.maxNumSegments != -1)
return true;
}
@@ -2669,7 +2667,7 @@ public class IndexWriter implements Clos
// NOTE: in the ConcurrentMergeScheduler case, when
// doWait is false, we can return immediately while
- // background threads accomplish the optimization
+ // background threads accomplish the merging
}
@@ -2682,14 +2680,14 @@ public class IndexWriter implements Clos
*
* <p>When an index
* has many document deletions (or updates to existing
- * documents), it's best to either call optimize or
+ * documents), it's best to either call forceMerge or
* expungeDeletes to remove all unused data in the index
* associated with the deleted documents. To see how
* many deletions you have pending in your index, call
* {@link IndexReader#numDeletedDocs}
* This saves disk space and memory usage while
* searching. expungeDeletes should be somewhat faster
- * than optimize since it does not insist on reducing the
+ * than forceMerge since it does not insist on reducing the
* index to a single segment (though, this depends on the
* {@link MergePolicy}; see {@link
* MergePolicy#findMergesToExpungeDeletes}.). Note that
@@ -2724,22 +2722,18 @@ public class IndexWriter implements Clos
* href="#OOME">above</a> for details.</p>
*/
public final void maybeMerge() throws CorruptIndexException, IOException {
- maybeMerge(false);
+ maybeMerge(-1);
}
- private final void maybeMerge(boolean optimize) throws CorruptIndexException, IOException {
- maybeMerge(1, optimize);
- }
-
- private final void maybeMerge(int maxNumSegmentsOptimize, boolean optimize) throws CorruptIndexException, IOException {
+ private final void maybeMerge(int maxNumSegments) throws CorruptIndexException, IOException {
ensureOpen(false);
- updatePendingMerges(maxNumSegmentsOptimize, optimize);
+ updatePendingMerges(maxNumSegments);
mergeScheduler.merge(this);
}
- private synchronized void updatePendingMerges(int maxNumSegmentsOptimize, boolean optimize)
+ private synchronized void updatePendingMerges(int maxNumSegments)
throws CorruptIndexException, IOException {
- assert !optimize || maxNumSegmentsOptimize > 0;
+ assert maxNumSegments == -1 || maxNumSegments > 0;
if (stopMerges) {
return;
@@ -2751,14 +2745,13 @@ public class IndexWriter implements Clos
}
final MergePolicy.MergeSpecification spec;
- if (optimize) {
- spec = mergePolicy.findMergesForOptimize(segmentInfos, maxNumSegmentsOptimize, Collections.unmodifiableMap(segmentsToOptimize));
+ if (maxNumSegments != -1) {
+ spec = mergePolicy.findForcedMerges(segmentInfos, maxNumSegments, Collections.unmodifiableMap(segmentsToMerge));
if (spec != null) {
final int numMerges = spec.merges.size();
for(int i=0;i<numMerges;i++) {
final MergePolicy.OneMerge merge = spec.merges.get(i);
- merge.optimize = true;
- merge.maxNumSegmentsOptimize = maxNumSegmentsOptimize;
+ merge.maxNumSegments = maxNumSegments;
}
}
@@ -2911,7 +2904,7 @@ public class IndexWriter implements Clos
*
* <p>NOTE: this method will forcefully abort all merges
* in progress. If other threads are running {@link
- * #optimize()}, {@link #addIndexes(IndexReader[])} or
+ * #forceMerge}, {@link #addIndexes(IndexReader[])} or
* {@link #expungeDeletes} methods, they may receive
* {@link MergePolicy.MergeAbortedException}s.
*/
@@ -3055,99 +3048,6 @@ public class IndexWriter implements Clos
addIndexes(dirs);
}
- /**
- * Merges the provided indexes into this index. This method is useful
- * if you use extensions of {@link IndexReader}. Otherwise, using
- * {@link #addIndexes(Directory...)} is highly recommended for performance
- * reasons. It uses the {@link MergeScheduler} and {@link MergePolicy} set
- * on this writer, which may perform merges in parallel.
- *
- * <p>The provided IndexReaders are not closed.
- *
- * <p><b>NOTE:</b> this method does not merge the current segments,
- * only the incoming ones.
- *
- * <p>See {@link #addIndexes(Directory...)} for details on transactional
- * semantics, temporary free space required in the Directory,
- * and non-CFS segments on an Exception.
- *
- * <p><b>NOTE</b>: if this method hits an OutOfMemoryError
- * you should immediately close the writer. See <a
- * href="#OOME">above</a> for details.
- *
- * <p><b>NOTE</b>: if you call {@link #close(boolean)}
- * with <tt>false</tt>, which aborts all running merges,
- * then any thread still running this method might hit a
- * {@link MergePolicy.MergeAbortedException}.
- *
- * @throws CorruptIndexException if the index is corrupt
- * @throws IOException if there is a low-level IO error
- */
- public void addIndexes(IndexReader... readers) throws CorruptIndexException, IOException {
-
- ensureOpen();
-
- try {
- if (infoStream != null)
- message("flush at addIndexes(IndexReader...)");
- flush(false, true);
-
- String mergedName = newSegmentName();
- // TODO: somehow we should fix this merge so it's
- // abortable so that IW.close(false) is able to stop it
- SegmentMerger merger = new SegmentMerger(directory, config.getTermIndexInterval(),
- mergedName, null, payloadProcessorProvider,
- ((FieldInfos) docWriter.getFieldInfos().clone()));
-
- for (IndexReader reader : readers) // add new indexes
- merger.add(reader);
-
- int docCount = merger.merge(); // merge 'em
-
- SegmentInfo info = new SegmentInfo(mergedName, docCount, directory,
- false, true,
- merger.fieldInfos().hasProx(),
- merger.fieldInfos().hasVectors());
- setDiagnostics(info, "addIndexes(IndexReader...)");
-
- boolean useCompoundFile;
- synchronized(this) { // Guard segmentInfos
- if (stopMerges) {
- deleter.deleteNewFiles(info.files());
- return;
- }
- ensureOpen();
- useCompoundFile = mergePolicy.useCompoundFile(segmentInfos, info);
- }
-
- // Now create the compound file if needed
- if (useCompoundFile) {
- merger.createCompoundFile(mergedName + ".cfs", info);
-
- // delete new non cfs files directly: they were never
- // registered with IFD
- synchronized(this) {
- deleter.deleteNewFiles(info.files());
- }
- info.setUseCompoundFile(true);
- }
-
- // Register the new segment
- synchronized(this) {
- if (stopMerges) {
- deleter.deleteNewFiles(info.files());
- return;
- }
- ensureOpen();
- segmentInfos.add(info);
- checkpoint();
- }
-
- } catch (OutOfMemoryError oom) {
- handleOOM(oom, "addIndexes(IndexReader...)");
- }
- }
-
/**
* Adds all segments from an array of indexes into this index.
*
@@ -3175,7 +3075,7 @@ public class IndexWriter implements Clos
* (including the starting index). If readers/searchers
* are open against the starting index, then temporary
* free space required will be higher by the size of the
- * starting index (see {@link #optimize()} for details).
+ * starting index (see {@link #forceMerge(int)} for details).
*
* <p>
* <b>NOTE:</b> this method only copies the segments of the incomning indexes
@@ -3258,6 +3158,99 @@ public class IndexWriter implements Clos
}
}
+ /**
+ * Merges the provided indexes into this index. This method is useful
+ * if you use extensions of {@link IndexReader}. Otherwise, using
+ * {@link #addIndexes(Directory...)} is highly recommended for performance
+ * reasons. It uses the {@link MergeScheduler} and {@link MergePolicy} set
+ * on this writer, which may perform merges in parallel.
+ *
+ * <p>The provided IndexReaders are not closed.
+ *
+ * <p><b>NOTE:</b> this method does not merge the current segments,
+ * only the incoming ones.
+ *
+ * <p>See {@link #addIndexes(Directory...)} for details on transactional
+ * semantics, temporary free space required in the Directory,
+ * and non-CFS segments on an Exception.
+ *
+ * <p><b>NOTE</b>: if this method hits an OutOfMemoryError
+ * you should immediately close the writer. See <a
+ * href="#OOME">above</a> for details.
+ *
+ * <p><b>NOTE</b>: if you call {@link #close(boolean)}
+ * with <tt>false</tt>, which aborts all running merges,
+ * then any thread still running this method might hit a
+ * {@link MergePolicy.MergeAbortedException}.
+ *
+ * @throws CorruptIndexException if the index is corrupt
+ * @throws IOException if there is a low-level IO error
+ */
+ public void addIndexes(IndexReader... readers) throws CorruptIndexException, IOException {
+
+ ensureOpen();
+
+ try {
+ if (infoStream != null)
+ message("flush at addIndexes(IndexReader...)");
+ flush(false, true);
+
+ String mergedName = newSegmentName();
+ // TODO: somehow we should fix this merge so it's
+ // abortable so that IW.close(false) is able to stop it
+ SegmentMerger merger = new SegmentMerger(directory, config.getTermIndexInterval(),
+ mergedName, null, payloadProcessorProvider,
+ ((FieldInfos) docWriter.getFieldInfos().clone()));
+
+ for (IndexReader reader : readers) // add new indexes
+ merger.add(reader);
+
+ int docCount = merger.merge(); // merge 'em
+
+ SegmentInfo info = new SegmentInfo(mergedName, docCount, directory,
+ false, true,
+ merger.fieldInfos().hasProx(),
+ merger.fieldInfos().hasVectors());
+ setDiagnostics(info, "addIndexes(IndexReader...)");
+
+ boolean useCompoundFile;
+ synchronized(this) { // Guard segmentInfos
+ if (stopMerges) {
+ deleter.deleteNewFiles(info.files());
+ return;
+ }
+ ensureOpen();
+ useCompoundFile = mergePolicy.useCompoundFile(segmentInfos, info);
+ }
+
+ // Now create the compound file if needed
+ if (useCompoundFile) {
+ merger.createCompoundFile(mergedName + ".cfs", info);
+
+ // delete new non cfs files directly: they were never
+ // registered with IFD
+ synchronized(this) {
+ deleter.deleteNewFiles(info.files());
+ }
+ info.setUseCompoundFile(true);
+ }
+
+ // Register the new segment
+ synchronized(this) {
+ if (stopMerges) {
+ deleter.deleteNewFiles(info.files());
+ return;
+ }
+ ensureOpen();
+ segmentInfos.add(info);
+ checkpoint();
+ }
+
+ } catch (OutOfMemoryError oom) {
+ handleOOM(oom, "addIndexes(IndexReader...)");
+ }
+ }
+
/** Copies the segment into the IndexWriter's directory, as a compound segment. */
private void copySegmentIntoCFS(SegmentInfo info, String segName) throws IOException {
String segFileName = IndexFileNames.segmentFileName(segName, IndexFileNames.COMPOUND_FILE_EXTENSION);
@@ -3450,7 +3443,7 @@ public class IndexWriter implements Clos
/**
* <p>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
@@ -3865,10 +3858,10 @@ public class IndexWriter implements Clos
// 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);
}
}
@@ -3882,7 +3875,7 @@ public class IndexWriter implements Clos
}
// 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);
@@ -3949,8 +3942,8 @@ public class IndexWriter implements Clos
// 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);
}
}
}
@@ -3994,9 +3987,8 @@ public class IndexWriter implements Clos
if (info.dir != directory) {
isExternal = true;
}
- if (segmentsToOptimize.containsKey(info)) {
- merge.optimize = true;
- merge.maxNumSegmentsOptimize = optimizeMaxNumSegments;
+ if (segmentsToMerge.containsKey(info)) {
+ merge.maxNumSegments = mergeMaxNumSegments;
}
}
@@ -4047,7 +4039,7 @@ public class IndexWriter implements Clos
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");
@@ -4105,7 +4097,7 @@ public class IndexWriter implements Clos
bufferedDeletesStream.prune(segmentInfos);
Map<String,String> details = new HashMap<String,String>();
- details.put("optimize", Boolean.toString(merge.optimize));
+ details.put("mergeMaxNumSegments", ""+merge.maxNumSegments);
details.put("mergeFactor", Integer.toString(merge.segments.size()));
setDiagnostics(merge.info, "merge", details);
@@ -4157,7 +4149,7 @@ public class IndexWriter implements Clos
* the synchronized lock on IndexWriter instance. */
final synchronized void mergeFinish(MergePolicy.OneMerge merge) throws IOException {
- // Optimize, addIndexes or finishMerges may be waiting
+ // forceMerge, addIndexes or finishMerges may be waiting
// on merges to finish.
notifyAll();
@@ -4825,7 +4817,7 @@ public class IndexWriter implements Clos
* <b>NOTE:</b> the set {@link PayloadProcessorProvider} will be in effect
* immediately, potentially for already running merges too. If you want to be
* sure it is used for further operations only, such as {@link #addIndexes} or
- * {@link #optimize}, you can call {@link #waitForMerges()} before.
+ * {@link #forceMerge}, you can call {@link #waitForMerges()} before.
*/
public void setPayloadProcessorProvider(PayloadProcessorProvider pcp) {
ensureOpen();
Modified: lucene/dev/branches/branch_3x/lucene/src/java/org/apache/lucene/index/IndexWriterConfig.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/branch_3x/lucene/src/java/org/apache/lucene/index/IndexWriterConfig.java?rev=1201265&r1=1201264&r2=1201265&view=diff
==============================================================================
--- lucene/dev/branches/branch_3x/lucene/src/java/org/apache/lucene/index/IndexWriterConfig.java (original)
+++ lucene/dev/branches/branch_3x/lucene/src/java/org/apache/lucene/index/IndexWriterConfig.java Sat Nov 12 14:09:28 2011
@@ -505,7 +505,7 @@ public final class IndexWriterConfig imp
* Expert: {@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
+ * It also selects merges to do for forceMerge. (The default is
* {@link LogByteSizeMergePolicy}.
*
* <p>Only takes effect when IndexWriter is first created. */
Modified: lucene/dev/branches/branch_3x/lucene/src/java/org/apache/lucene/index/LogByteSizeMergePolicy.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/branch_3x/lucene/src/java/org/apache/lucene/index/LogByteSizeMergePolicy.java?rev=1201265&r1=1201264&r2=1201265&view=diff
==============================================================================
--- lucene/dev/branches/branch_3x/lucene/src/java/org/apache/lucene/index/LogByteSizeMergePolicy.java (original)
+++ lucene/dev/branches/branch_3x/lucene/src/java/org/apache/lucene/index/LogByteSizeMergePolicy.java Sat Nov 12 14:09:28 2011
@@ -31,13 +31,13 @@ public class LogByteSizeMergePolicy exte
public static final double DEFAULT_MAX_MERGE_MB = 2048;
/** Default maximum segment size. A segment of this size
- * or larger will never be merged during optimize. @see setMaxMergeMBForOptimize */
- public static final double DEFAULT_MAX_MERGE_MB_FOR_OPTIMIZE = Long.MAX_VALUE;
+ * or larger will never be merged during forceMerge. @see setMaxMergeMBForForceMerge */
+ public static final double DEFAULT_MAX_MERGE_MB_FOR_FORCED_MERGE = Long.MAX_VALUE;
public LogByteSizeMergePolicy() {
minMergeSize = (long) (DEFAULT_MIN_MERGE_MB*1024*1024);
maxMergeSize = (long) (DEFAULT_MAX_MERGE_MB*1024*1024);
- maxMergeSizeForOptimize = (long) (DEFAULT_MAX_MERGE_MB_FOR_OPTIMIZE*1024*1024);
+ maxMergeSizeForForcedMerge = (long) (DEFAULT_MAX_MERGE_MB_FOR_FORCED_MERGE*1024*1024);
}
@Override
@@ -68,21 +68,35 @@ public class LogByteSizeMergePolicy exte
return ((double) maxMergeSize)/1024/1024;
}
+ /** @deprecated Renamed to {@link
+ * #setMaxMergeMBForForcedMerge} */
+ @Deprecated
+ public void setMaxMergeMBForOptimize(double mb) {
+ setMaxMergeMBForForcedMerge(mb);
+ }
+
/** <p>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);
+ }
+
+ /** @deprecated Renamed to {@link
+ * #getMaxMergeMBForForcedMerge} */
+ @Deprecated
+ public double getMaxMergeMBForOptimize() {
+ return getMaxMergeMBForForcedMerge();
}
/** 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.
Modified: lucene/dev/branches/branch_3x/lucene/src/java/org/apache/lucene/index/LogDocMergePolicy.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/branch_3x/lucene/src/java/org/apache/lucene/index/LogDocMergePolicy.java?rev=1201265&r1=1201264&r2=1201265&view=diff
==============================================================================
--- lucene/dev/branches/branch_3x/lucene/src/java/org/apache/lucene/index/LogDocMergePolicy.java (original)
+++ lucene/dev/branches/branch_3x/lucene/src/java/org/apache/lucene/index/LogDocMergePolicy.java Sat Nov 12 14:09:28 2011
@@ -31,10 +31,10 @@ public class LogDocMergePolicy extends L
public LogDocMergePolicy() {
minMergeSize = DEFAULT_MIN_MERGE_DOCS;
- // maxMergeSize(ForOptimize) are never used by LogDocMergePolicy; set
+ // maxMergeSize(ForForcedMerge) are never used by LogDocMergePolicy; set
// it to Long.MAX_VALUE to disable it
maxMergeSize = Long.MAX_VALUE;
- maxMergeSizeForOptimize = Long.MAX_VALUE;
+ maxMergeSizeForForcedMerge = Long.MAX_VALUE;
}
@Override
Modified: lucene/dev/branches/branch_3x/lucene/src/java/org/apache/lucene/index/LogMergePolicy.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/branch_3x/lucene/src/java/org/apache/lucene/index/LogMergePolicy.java?rev=1201265&r1=1201264&r2=1201265&view=diff
==============================================================================
--- lucene/dev/branches/branch_3x/lucene/src/java/org/apache/lucene/index/LogMergePolicy.java (original)
+++ lucene/dev/branches/branch_3x/lucene/src/java/org/apache/lucene/index/LogMergePolicy.java Sat Nov 12 14:09:28 2011
@@ -32,13 +32,13 @@ import java.util.Map;
* set the merge factor using {@link #getMergeFactor()} and
* {@link #setMergeFactor(int)} respectively.</p>
*
- * <p>This class is abstract and requires a subclass to
- * define the {@link #size} method which specifies how a
- * segment's size is determined. {@link LogDocMergePolicy}
- * is one subclass that measures size by document count in
- * the segment. {@link LogByteSizeMergePolicy} is another
- * subclass that measures size as the total byte size of the
- * file(s) for the segment.</p>
+ * <p>This class is abstract and requires a subclass to
+ * define the {@link #size} method which specifies how a
+ * segment's size is determined. {@link LogDocMergePolicy}
+ * is one subclass that measures size by document count in
+ * the segment. {@link LogByteSizeMergePolicy} is another
+ * subclass that measures size as the total byte size of the
+ * file(s) for the segment.</p>
*/
public abstract class LogMergePolicy extends MergePolicy {
@@ -68,7 +68,7 @@ public abstract class LogMergePolicy ext
protected long maxMergeSize;
// Although the core MPs set it explicitly, we must default in case someone
// out there wrote his own LMP ...
- protected long maxMergeSizeForOptimize = Long.MAX_VALUE;
+ protected long maxMergeSizeForForcedMerge = Long.MAX_VALUE;
protected int maxMergeDocs = DEFAULT_MAX_MERGE_DOCS;
protected double noCFSRatio = DEFAULT_NO_CFS_RATIO;
@@ -117,10 +117,10 @@ public abstract class LogMergePolicy ext
/** Determines how often segment indices are merged by
* addDocument(). With smaller values, less RAM is used
- * while indexing, and searches on unoptimized indices are
+ * while indexing, and searches are
* faster, but indexing speed is slower. With larger
* values, more RAM is used during indexing, and while
- * searches on unoptimized indices are slower, indexing is
+ * searches is slower, indexing is
* faster. Thus larger values (> 10) are best for batch
* index creation, and smaller values (< 10) for indices
* that are interactively maintained. */
@@ -201,29 +201,29 @@ public abstract class LogMergePolicy ext
}
}
- protected boolean isOptimized(SegmentInfos infos, int maxNumSegments, Map<SegmentInfo,Boolean> segmentsToOptimize) throws IOException {
+ protected boolean isMerged(SegmentInfos infos, int maxNumSegments, Map<SegmentInfo,Boolean> segmentsToMerge) throws IOException {
final int numSegments = infos.size();
- int numToOptimize = 0;
- SegmentInfo optimizeInfo = null;
+ int numToMerge = 0;
+ SegmentInfo mergeInfo = null;
boolean segmentIsOriginal = false;
- for(int i=0;i<numSegments && numToOptimize <= maxNumSegments;i++) {
+ for(int i=0;i<numSegments && numToMerge <= maxNumSegments;i++) {
final SegmentInfo info = infos.info(i);
- final Boolean isOriginal = segmentsToOptimize.get(info);
+ final Boolean isOriginal = segmentsToMerge.get(info);
if (isOriginal != null) {
segmentIsOriginal = isOriginal;
- numToOptimize++;
- optimizeInfo = info;
+ numToMerge++;
+ mergeInfo = info;
}
}
- return numToOptimize <= maxNumSegments &&
- (numToOptimize != 1 || !segmentIsOriginal || isOptimized(optimizeInfo));
+ return numToMerge <= maxNumSegments &&
+ (numToMerge != 1 || !segmentIsOriginal || isMerged(mergeInfo));
}
- /** Returns true if this single info is optimized (has no
+ /** Returns true if this single info is already fully merged (has no
* pending norms or deletes, is in the same dir as the
* writer, and matches the current compound file setting */
- protected boolean isOptimized(SegmentInfo info)
+ protected boolean isMerged(SegmentInfo info)
throws IOException {
IndexWriter w = writer.get();
assert w != null;
@@ -235,14 +235,14 @@ public abstract class LogMergePolicy ext
}
/**
- * Returns the merges necessary to optimize the index, taking the max merge
+ * Returns the merges necessary to merge the index, taking the max merge
* size or max merge docs into consideration. This method attempts to respect
* the {@code maxNumSegments} parameter, however it might be, due to size
* constraints, that more than that number of segments will remain in the
* index. Also, this method does not guarantee that exactly {@code
* maxNumSegments} will remain, but <= that number.
*/
- private MergeSpecification findMergesForOptimizeSizeLimit(
+ private MergeSpecification findForcedMergesSizeLimit(
SegmentInfos infos, int maxNumSegments, int last) throws IOException {
MergeSpecification spec = new MergeSpecification();
final List<SegmentInfo> segments = infos.asList();
@@ -250,14 +250,15 @@ public abstract class LogMergePolicy ext
int start = last - 1;
while (start >= 0) {
SegmentInfo info = infos.info(start);
- if (size(info) > maxMergeSizeForOptimize || sizeDocs(info) > maxMergeDocs) {
+ if (size(info) > maxMergeSizeForForcedMerge || sizeDocs(info) > maxMergeDocs) {
if (verbose()) {
- message("optimize: skip segment=" + info + ": size is > maxMergeSize (" + maxMergeSizeForOptimize + ") or sizeDocs is > maxMergeDocs (" + maxMergeDocs + ")");
+ message("findForcedMergesSizeLimit: skip segment=" + info + ": size is > maxMergeSize (" + maxMergeSizeForForcedMerge + ") or sizeDocs is > maxMergeDocs (" + maxMergeDocs + ")");
}
// need to skip that segment + add a merge for the 'right' segments,
- // unless there is only 1 which is optimized.
- if (last - start - 1 > 1 || (start != last - 1 && !isOptimized(infos.info(start + 1)))) {
- // there is more than 1 segment to the right of this one, or an unoptimized single segment.
+ // unless there is only 1 which is merged.
+ if (last - start - 1 > 1 || (start != last - 1 && !isMerged(infos.info(start + 1)))) {
+ // there is more than 1 segment to the right of
+ // this one, or a mergeable single segment.
spec.add(new OneMerge(segments.subList(start + 1, last)));
}
last = start;
@@ -269,8 +270,9 @@ public abstract class LogMergePolicy ext
--start;
}
- // Add any left-over segments, unless there is just 1 already optimized.
- if (last > 0 && (++start + 1 < last || !isOptimized(infos.info(start)))) {
+ // Add any left-over segments, unless there is just 1
+ // already fully merged
+ if (last > 0 && (++start + 1 < last || !isMerged(infos.info(start)))) {
spec.add(new OneMerge(segments.subList(start, last)));
}
@@ -278,11 +280,11 @@ public abstract class LogMergePolicy ext
}
/**
- * Returns the merges necessary to optimize the index. This method constraints
+ * Returns the merges necessary to forceMerge the index. This method constraints
* the returned merges only by the {@code maxNumSegments} parameter, and
* guaranteed that exactly that number of segments will remain in the index.
*/
- private MergeSpecification findMergesForOptimizeMaxNumSegments(SegmentInfos infos, int maxNumSegments, int last) throws IOException {
+ private MergeSpecification findForcedMergesMaxNumSegments(SegmentInfos infos, int maxNumSegments, int last) throws IOException {
MergeSpecification spec = new MergeSpecification();
final List<SegmentInfo> segments = infos.asList();
@@ -298,9 +300,9 @@ public abstract class LogMergePolicy ext
if (0 == spec.merges.size()) {
if (maxNumSegments == 1) {
- // Since we must optimize down to 1 segment, the
+ // Since we must merge down to 1 segment, the
// choice is simple:
- if (last > 1 || !isOptimized(infos.info(0))) {
+ if (last > 1 || !isMerged(infos.info(0))) {
spec.add(new OneMerge(segments.subList(0, last)));
}
} else if (last > maxNumSegments) {
@@ -313,7 +315,7 @@ public abstract class LogMergePolicy ext
// We must merge this many segments to leave
// maxNumSegments in the index (from when
- // optimize was first kicked off):
+ // forceMerge was first kicked off):
final int finalMergeSize = last - maxNumSegments + 1;
// Consider all possible starting points:
@@ -336,10 +338,9 @@ public abstract class LogMergePolicy ext
return spec.merges.size() == 0 ? null : spec;
}
- /** Returns the merges necessary to optimize the index.
- * This merge policy defines "optimized" to mean only the
- * requested number of segments is left in the index, and
- * respects the {@link #maxMergeSizeForOptimize} setting.
+ /** Returns the merges necessary to merge the index down
+ * to a specified number of segments.
+ * This respects the {@link #maxMergeSizeForForcedMerge} setting.
* By default, and assuming {@code maxNumSegments=1}, only
* one segment will be left in the index, where that segment
* has no deletions pending nor separate norms, and it is in
@@ -348,25 +349,30 @@ public abstract class LogMergePolicy ext
* (mergeFactor at a time) so the {@link MergeScheduler}
* in use may make use of concurrency. */
@Override
- public MergeSpecification findMergesForOptimize(SegmentInfos infos,
- int maxNumSegments, Map<SegmentInfo,Boolean> segmentsToOptimize) throws IOException {
+ public MergeSpecification findForcedMerges(SegmentInfos infos,
+ int maxNumSegments, Map<SegmentInfo,Boolean> segmentsToMerge) throws IOException {
assert maxNumSegments > 0;
if (verbose()) {
- message("findMergesForOptimize: maxNumSegs=" + maxNumSegments + " segsToOptimize="+ segmentsToOptimize);
+ message("findForcedMerges: maxNumSegs=" + maxNumSegments + " segsToMerge="+ segmentsToMerge);
}
- // If the segments are already optimized (e.g. there's only 1 segment), or
- // there are <maxNumSegements, all optimized, nothing to do.
- if (isOptimized(infos, maxNumSegments, segmentsToOptimize)) return null;
+ // If the segments are already merged (e.g. there's only 1 segment), or
+ // there are <maxNumSegements:.
+ if (isMerged(infos, maxNumSegments, segmentsToMerge)) {
+ if (verbose()) {
+ message("already merged; skip");
+ }
+ return null;
+ }
// Find the newest (rightmost) segment that needs to
- // be optimized (other segments may have been flushed
- // since optimize started):
+ // be merged (other segments may have been flushed
+ // since merging started):
int last = infos.size();
while (last > 0) {
final SegmentInfo info = infos.info(--last);
- if (segmentsToOptimize.get(info) != null) {
+ if (segmentsToMerge.get(info) != null) {
last++;
break;
}
@@ -374,23 +380,28 @@ public abstract class LogMergePolicy ext
if (last == 0) return null;
- // There is only one segment already, and it is optimized
- if (maxNumSegments == 1 && last == 1 && isOptimized(infos.info(0))) return null;
+ // There is only one segment already, and it is merged
+ if (maxNumSegments == 1 && last == 1 && isMerged(infos.info(0))) {
+ if (verbose()) {
+ message("already 1 seg; skip");
+ }
+ return null;
+ }
// Check if there are any segments above the threshold
boolean anyTooLarge = false;
for (int i = 0; i < last; i++) {
SegmentInfo info = infos.info(i);
- if (size(info) > maxMergeSizeForOptimize || sizeDocs(info) > maxMergeDocs) {
+ if (size(info) > maxMergeSizeForForcedMerge || sizeDocs(info) > maxMergeDocs) {
anyTooLarge = true;
break;
}
}
if (anyTooLarge) {
- return findMergesForOptimizeSizeLimit(infos, maxNumSegments, last);
+ return findForcedMergesSizeLimit(infos, maxNumSegments, last);
} else {
- return findMergesForOptimizeMaxNumSegments(infos, maxNumSegments, last);
+ return findForcedMergesMaxNumSegments(infos, maxNumSegments, last);
}
}
@@ -640,7 +651,7 @@ public abstract class LogMergePolicy ext
sb.append("minMergeSize=").append(minMergeSize).append(", ");
sb.append("mergeFactor=").append(mergeFactor).append(", ");
sb.append("maxMergeSize=").append(maxMergeSize).append(", ");
- sb.append("maxMergeSizeForOptimize=").append(maxMergeSizeForOptimize).append(", ");
+ sb.append("maxMergeSizeForForcedMerge=").append(maxMergeSizeForForcedMerge).append(", ");
sb.append("calibrateSizeByDeletes=").append(calibrateSizeByDeletes).append(", ");
sb.append("maxMergeDocs=").append(maxMergeDocs).append(", ");
sb.append("useCompoundFile=").append(useCompoundFile).append(", ");
Modified: lucene/dev/branches/branch_3x/lucene/src/java/org/apache/lucene/index/MergePolicy.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/branch_3x/lucene/src/java/org/apache/lucene/index/MergePolicy.java?rev=1201265&r1=1201264&r2=1201265&view=diff
==============================================================================
--- lucene/dev/branches/branch_3x/lucene/src/java/org/apache/lucene/index/MergePolicy.java (original)
+++ lucene/dev/branches/branch_3x/lucene/src/java/org/apache/lucene/index/MergePolicy.java Sat Nov 12 14:09:28 2011
@@ -28,8 +28,7 @@ import java.util.Map;
/**
* <p>Expert: a MergePolicy determines the sequence of
- * primitive merge operations to be used for overall merge
- * and optimize operations.</p>
+ * primitive merge operations.</p>
*
* <p>Whenever the segments in an index have been altered by
* {@link IndexWriter}, either the addition of a newly
@@ -40,8 +39,8 @@ import java.util.Map;
* 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.</p>
*
* <p>Note that the policy can return more than one merge at
@@ -67,11 +66,10 @@ public abstract class MergePolicy implem
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<SegmentReader> readers; // used by IndexWriter
List<SegmentReader> readerClones; // used by IndexWriter
@@ -158,8 +156,8 @@ public abstract class MergePolicy implem
}
if (info != null)
b.append(" into ").append(info.name);
- if (optimize)
- b.append(" [optimize]");
+ if (maxNumSegments != -1)
+ b.append(" [maxNumSegments=" + maxNumSegments + "]");
if (aborted) {
b.append(" [ABORTED]");
}
@@ -284,9 +282,9 @@ public abstract class MergePolicy implem
throws CorruptIndexException, IOException;
/**
- * Determine what set of merge operations is necessary in order to optimize
- * the index. {@link IndexWriter} calls this when its
- * {@link IndexWriter#optimize()} method is called. This call is always
+ * Determine what set of merge operations is necessary in
+ * order to merge to <= the specified segment count. {@link IndexWriter} calls this when its
+ * {@link IndexWriter#forceMerge} method is called. This call is always
* synchronized on the {@link IndexWriter} instance so only one thread at a
* time will call this method.
*
@@ -295,17 +293,17 @@ public abstract class MergePolicy implem
* @param maxSegmentCount
* requested maximum number of segments in the index (currently this
* is always 1)
- * @param segmentsToOptimize
+ * @param segmentsToMerge
* contains the specific SegmentInfo instances that must be merged
* away. This may be a subset of all
* SegmentInfos. If the value is True for a
* given SegmentInfo, that means this segment was
* an original segment present in the
- * to-be-optimized index; else, it was a segment
+ * to-be-merged index; else, it was a segment
* produced by a cascaded merge.
*/
- public abstract MergeSpecification findMergesForOptimize(
- SegmentInfos segmentInfos, int maxSegmentCount, Map<SegmentInfo,Boolean> segmentsToOptimize)
+ public abstract MergeSpecification findForcedMerges(
+ SegmentInfos segmentInfos, int maxSegmentCount, Map<SegmentInfo,Boolean> segmentsToMerge)
throws CorruptIndexException, IOException;
/**
Modified: lucene/dev/branches/branch_3x/lucene/src/java/org/apache/lucene/index/MultiReader.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/branch_3x/lucene/src/java/org/apache/lucene/index/MultiReader.java?rev=1201265&r1=1201264&r2=1201265&view=diff
==============================================================================
--- lucene/dev/branches/branch_3x/lucene/src/java/org/apache/lucene/index/MultiReader.java (original)
+++ lucene/dev/branches/branch_3x/lucene/src/java/org/apache/lucene/index/MultiReader.java Sat Nov 12 14:09:28 2011
@@ -220,12 +220,13 @@ public class MultiReader extends IndexRe
subReaders[i].getTermFreqVector(docNumber - starts[i], mapper);
}
+ @Deprecated
@Override
public boolean isOptimized() {
ensureOpen();
return false;
}
-
+
@Override
public int numDocs() {
// Don't call ensureOpen() here (it could affect performance)
Modified: lucene/dev/branches/branch_3x/lucene/src/java/org/apache/lucene/index/NoMergePolicy.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/branch_3x/lucene/src/java/org/apache/lucene/index/NoMergePolicy.java?rev=1201265&r1=1201264&r2=1201265&view=diff
==============================================================================
--- lucene/dev/branches/branch_3x/lucene/src/java/org/apache/lucene/index/NoMergePolicy.java (original)
+++ lucene/dev/branches/branch_3x/lucene/src/java/org/apache/lucene/index/NoMergePolicy.java Sat Nov 12 14:09:28 2011
@@ -58,8 +58,8 @@ public final class NoMergePolicy extends
throws CorruptIndexException, IOException { return null; }
@Override
- public MergeSpecification findMergesForOptimize(SegmentInfos segmentInfos,
- int maxSegmentCount, Map<SegmentInfo,Boolean> segmentsToOptimize)
+ public MergeSpecification findForcedMerges(SegmentInfos segmentInfos,
+ int maxSegmentCount, Map<SegmentInfo,Boolean> segmentsToMerge)
throws CorruptIndexException, IOException { return null; }
@Override
Modified: lucene/dev/branches/branch_3x/lucene/src/java/org/apache/lucene/index/ParallelReader.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/branch_3x/lucene/src/java/org/apache/lucene/index/ParallelReader.java?rev=1201265&r1=1201264&r2=1201265&view=diff
==============================================================================
--- lucene/dev/branches/branch_3x/lucene/src/java/org/apache/lucene/index/ParallelReader.java (original)
+++ lucene/dev/branches/branch_3x/lucene/src/java/org/apache/lucene/index/ParallelReader.java Sat Nov 12 14:09:28 2011
@@ -448,9 +448,7 @@ public class ParallelReader extends Inde
return true;
}
- /**
- * Checks recursively if all subindexes are optimized
- */
+ @Deprecated
@Override
public boolean isOptimized() {
ensureOpen();
@@ -464,7 +462,6 @@ public class ParallelReader extends Inde
return true;
}
-
/** Not implemented.
* @throws UnsupportedOperationException
*/
Modified: lucene/dev/branches/branch_3x/lucene/src/java/org/apache/lucene/index/SnapshotDeletionPolicy.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/branch_3x/lucene/src/java/org/apache/lucene/index/SnapshotDeletionPolicy.java?rev=1201265&r1=1201264&r2=1201265&view=diff
==============================================================================
--- lucene/dev/branches/branch_3x/lucene/src/java/org/apache/lucene/index/SnapshotDeletionPolicy.java (original)
+++ lucene/dev/branches/branch_3x/lucene/src/java/org/apache/lucene/index/SnapshotDeletionPolicy.java Sat Nov 12 14:09:28 2011
@@ -136,8 +136,8 @@ public class SnapshotDeletionPolicy impl
}
@Override
- public boolean isOptimized() {
- return cp.isOptimized();
+ public int getSegmentCount() {
+ return cp.getSegmentCount();
}
}
@@ -340,7 +340,7 @@ public class SnapshotDeletionPolicy impl
* <b>NOTE:</b> while the snapshot is held, the files it references will not
* be deleted, which will consume additional disk space in your index. If you
* take a snapshot at a particularly bad time (say just before you call
- * optimize()) then in the worst case this could consume an extra 1X of your
+ * forceMerge) then in the worst case this could consume an extra 1X of your
* total index size, until you release the snapshot.
*
* @param id
Modified: lucene/dev/branches/branch_3x/lucene/src/java/org/apache/lucene/index/TieredMergePolicy.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/branch_3x/lucene/src/java/org/apache/lucene/index/TieredMergePolicy.java?rev=1201265&r1=1201264&r2=1201265&view=diff
==============================================================================
--- lucene/dev/branches/branch_3x/lucene/src/java/org/apache/lucene/index/TieredMergePolicy.java (original)
+++ lucene/dev/branches/branch_3x/lucene/src/java/org/apache/lucene/index/TieredMergePolicy.java Sat Nov 12 14:09:28 2011
@@ -60,7 +60,7 @@ import java.util.ArrayList;
* <p><b>NOTE</b>: 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
*/
@@ -86,7 +86,7 @@ public class TieredMergePolicy extends M
/** 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) {
@@ -105,7 +105,7 @@ public class TieredMergePolicy extends M
// 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 + ")");
@@ -476,23 +476,23 @@ public class TieredMergePolicy extends M
}
@Override
- public MergeSpecification findMergesForOptimize(SegmentInfos infos, int maxSegmentCount, Map<SegmentInfo,Boolean> segmentsToOptimize) throws IOException {
+ public MergeSpecification findForcedMerges(SegmentInfos infos, int maxSegmentCount, Map<SegmentInfo,Boolean> segmentsToMerge) throws IOException {
if (verbose()) {
- message("findMergesForOptimize maxSegmentCount=" + maxSegmentCount + " infos=" + writer.get().segString(infos) + " segmentsToOptimize=" + segmentsToOptimize);
+ message("findForcedMerges maxSegmentCount=" + maxSegmentCount + " infos=" + writer.get().segString(infos) + " segmentsToMerge=" + segmentsToMerge);
}
List<SegmentInfo> eligible = new ArrayList<SegmentInfo>();
- boolean optimizeMergeRunning = false;
+ boolean forceMergeRunning = false;
final Collection<SegmentInfo> merging = writer.get().getMergingSegments();
boolean segmentIsOriginal = false;
for(SegmentInfo info : infos) {
- final Boolean isOriginal = segmentsToOptimize.get(info);
+ final Boolean isOriginal = segmentsToMerge.get(info);
if (isOriginal != null) {
segmentIsOriginal = isOriginal;
if (!merging.contains(info)) {
eligible.add(info);
} else {
- optimizeMergeRunning = true;
+ forceMergeRunning = true;
}
}
}
@@ -502,9 +502,9 @@ public class TieredMergePolicy extends M
}
if ((maxSegmentCount > 1 && eligible.size() <= maxSegmentCount) ||
- (maxSegmentCount == 1 && eligible.size() == 1 && (!segmentIsOriginal || isOptimized(eligible.get(0))))) {
+ (maxSegmentCount == 1 && eligible.size() == 1 && (!segmentIsOriginal || isMerged(eligible.get(0))))) {
if (verbose()) {
- message("already optimized");
+ message("already merged");
}
return null;
}
@@ -513,7 +513,7 @@ public class TieredMergePolicy extends M
if (verbose()) {
message("eligible=" + eligible);
- message("optimizeMergeRunning=" + optimizeMergeRunning);
+ message("forceMergeRunning=" + forceMergeRunning);
}
int end = eligible.size();
@@ -533,7 +533,7 @@ public class TieredMergePolicy extends M
end -= maxMergeAtOnceExplicit;
}
- if (spec == null && !optimizeMergeRunning) {
+ if (spec == null && !forceMergeRunning) {
// Do final merge
final int numToMerge = end - maxSegmentCount + 1;
final OneMerge merge = new OneMerge(eligible.subList(end-numToMerge, end));
@@ -578,7 +578,7 @@ public class TieredMergePolicy extends M
while(start < eligible.size()) {
// Don't enforce max merged size here: app is explicitly
// calling expungeDeletes, and knows this may take a
- // long time / produce big segments (like optimize):
+ // long time / produce big segments (like forceMerge):
final int end = Math.min(start + maxMergeAtOnceExplicit, eligible.size());
if (spec == null) {
spec = new MergeSpecification();
@@ -617,7 +617,7 @@ public class TieredMergePolicy extends M
public void close() {
}
- private boolean isOptimized(SegmentInfo info)
+ private boolean isMerged(SegmentInfo info)
throws IOException {
IndexWriter w = writer.get();
assert w != null;
Modified: lucene/dev/branches/branch_3x/lucene/src/java/org/apache/lucene/index/UpgradeIndexMergePolicy.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/branch_3x/lucene/src/java/org/apache/lucene/index/UpgradeIndexMergePolicy.java?rev=1201265&r1=1201264&r2=1201265&view=diff
==============================================================================
--- lucene/dev/branches/branch_3x/lucene/src/java/org/apache/lucene/index/UpgradeIndexMergePolicy.java (original)
+++ lucene/dev/branches/branch_3x/lucene/src/java/org/apache/lucene/index/UpgradeIndexMergePolicy.java Sat Nov 12 14:09:28 2011
@@ -26,24 +26,24 @@ import java.util.Map;
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.
* <p>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)}:
* <pre class="prettyprint lang-java">
* 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();
* </pre>
* <p><b>Warning:</b> 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
@@ -52,7 +52,7 @@ public class UpgradeIndexMergePolicy ext
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;
@@ -79,22 +79,22 @@ public class UpgradeIndexMergePolicy ext
}
@Override
- public MergeSpecification findMergesForOptimize(SegmentInfos segmentInfos, int maxSegmentCount, Map<SegmentInfo,Boolean> segmentsToOptimize) throws CorruptIndexException, IOException {
+ public MergeSpecification findForcedMerges(SegmentInfos segmentInfos, int maxSegmentCount, Map<SegmentInfo,Boolean> segmentsToMerge) throws CorruptIndexException, IOException {
// first find all old segments
final Map<SegmentInfo,Boolean> oldSegments = new HashMap<SegmentInfo,Boolean>();
for (final SegmentInfo si : segmentInfos) {
- final Boolean v =segmentsToOptimize.get(si);
+ final Boolean v = segmentsToMerge.get(si);
if (v != null && shouldUpgradeSegment(si)) {
oldSegments.put(si, v);
}
}
- if (verbose()) message("findMergesForOptimize: segmentsToUpgrade=" + oldSegments);
+ if (verbose()) message("findForcedMerges: segmentsToUpgrade=" + oldSegments);
if (oldSegments.isEmpty())
return null;
- MergeSpecification spec = base.findMergesForOptimize(segmentInfos, maxSegmentCount, oldSegments);
+ MergeSpecification spec = base.findForcedMerges(segmentInfos, maxSegmentCount, oldSegments);
if (spec != null) {
// remove all segments that are in merge specification from oldSegments,
@@ -107,7 +107,7 @@ public class UpgradeIndexMergePolicy ext
if (!oldSegments.isEmpty()) {
if (verbose())
- message("findMergesForOptimize: " + base.getClass().getSimpleName() +
+ message("findForcedMerges: " + base.getClass().getSimpleName() +
" does not want to merge all old segments, merge remaining ones into new segment: " + oldSegments);
final List<SegmentInfo> newInfos = new ArrayList<SegmentInfo>();
for (final SegmentInfo si : segmentInfos) {
Modified: lucene/dev/branches/branch_3x/lucene/src/java/org/apache/lucene/search/MultiTermQuery.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/branch_3x/lucene/src/java/org/apache/lucene/search/MultiTermQuery.java?rev=1201265&r1=1201264&r2=1201265&view=diff
==============================================================================
--- lucene/dev/branches/branch_3x/lucene/src/java/org/apache/lucene/search/MultiTermQuery.java (original)
+++ lucene/dev/branches/branch_3x/lucene/src/java/org/apache/lucene/search/MultiTermQuery.java Sat Nov 12 14:09:28 2011
@@ -257,14 +257,14 @@ public abstract class MultiTermQuery ext
/**
* 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.
* <p>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}.
- * <p>On optimized indexes / no MultiReaders, you get the correct number of
+ * <p>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
Modified: lucene/dev/branches/branch_3x/lucene/src/test-framework/java/org/apache/lucene/analysis/CollationTestBase.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/branch_3x/lucene/src/test-framework/java/org/apache/lucene/analysis/CollationTestBase.java?rev=1201265&r1=1201264&r2=1201265&view=diff
==============================================================================
--- lucene/dev/branches/branch_3x/lucene/src/test-framework/java/org/apache/lucene/analysis/CollationTestBase.java (original)
+++ lucene/dev/branches/branch_3x/lucene/src/test-framework/java/org/apache/lucene/analysis/CollationTestBase.java Sat Nov 12 14:09:28 2011
@@ -18,10 +18,6 @@ package org.apache.lucene.analysis;
*/
-import org.apache.lucene.analysis.Analyzer;
-import org.apache.lucene.analysis.PerFieldAnalyzerWrapper;
-import org.apache.lucene.analysis.WhitespaceAnalyzer;
-import org.apache.lucene.analysis.TokenStream;
import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;
import org.apache.lucene.store.RAMDirectory;
import org.apache.lucene.index.IndexWriter;
@@ -228,7 +224,7 @@ public abstract class CollationTestBase
Field.Store.NO, Field.Index.ANALYZED));
writer.addDocument(doc);
}
- writer.optimize();
+ writer.forceMerge(1);
writer.close();
Searcher searcher = new IndexSearcher(indexStore, true);
Modified: lucene/dev/branches/branch_3x/lucene/src/test-framework/java/org/apache/lucene/index/MockRandomMergePolicy.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/branch_3x/lucene/src/test-framework/java/org/apache/lucene/index/MockRandomMergePolicy.java?rev=1201265&r1=1201264&r2=1201265&view=diff
==============================================================================
--- lucene/dev/branches/branch_3x/lucene/src/test-framework/java/org/apache/lucene/index/MockRandomMergePolicy.java (original)
+++ lucene/dev/branches/branch_3x/lucene/src/test-framework/java/org/apache/lucene/index/MockRandomMergePolicy.java Sat Nov 12 14:09:28 2011
@@ -55,18 +55,18 @@ public class MockRandomMergePolicy exten
}
@Override
- public MergeSpecification findMergesForOptimize(
- SegmentInfos segmentInfos, int maxSegmentCount, Map<SegmentInfo,Boolean> segmentsToOptimize)
+ public MergeSpecification findForcedMerges(
+ SegmentInfos segmentInfos, int maxSegmentCount, Map<SegmentInfo,Boolean> segmentsToMerge)
throws CorruptIndexException, IOException {
final List<SegmentInfo> eligibleSegments = new ArrayList<SegmentInfo>();
for(SegmentInfo info : segmentInfos) {
- if (segmentsToOptimize.containsKey(info)) {
+ if (segmentsToMerge.containsKey(info)) {
eligibleSegments.add(info);
}
}
- //System.out.println("MRMP: findMergesForOptimize sis=" + segmentInfos + " eligible=" + eligibleSegments);
+ //System.out.println("MRMP: findMerges sis=" + segmentInfos + " eligible=" + eligibleSegments);
MergeSpecification mergeSpec = null;
if (eligibleSegments.size() > 1 || (eligibleSegments.size() == 1 && eligibleSegments.get(0).hasDeletions())) {
mergeSpec = new MergeSpecification();
@@ -85,7 +85,7 @@ public class MockRandomMergePolicy exten
if (mergeSpec != null) {
for(OneMerge merge : mergeSpec.merges) {
for(SegmentInfo info : merge.segments) {
- assert segmentsToOptimize.containsKey(info);
+ assert segmentsToMerge.containsKey(info);
}
}
}
Modified: lucene/dev/branches/branch_3x/lucene/src/test-framework/java/org/apache/lucene/index/RandomIndexWriter.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/branch_3x/lucene/src/test-framework/java/org/apache/lucene/index/RandomIndexWriter.java?rev=1201265&r1=1201264&r2=1201265&view=diff
==============================================================================
--- lucene/dev/branches/branch_3x/lucene/src/test-framework/java/org/apache/lucene/index/RandomIndexWriter.java (original)
+++ lucene/dev/branches/branch_3x/lucene/src/test-framework/java/org/apache/lucene/index/RandomIndexWriter.java Sat Nov 12 14:09:28 2011
@@ -35,7 +35,7 @@ import org.apache.lucene.util._TestUtil;
/** 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.
*/
@@ -176,8 +176,8 @@ public class RandomIndexWriter implement
w.deleteAll();
}
- 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);
@@ -187,25 +187,25 @@ public class RandomIndexWriter implement
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();
}
}
}
@@ -217,7 +217,7 @@ public class RandomIndexWriter implement
public IndexReader getReader(boolean applyDeletions) throws IOException {
getReaderCalled = true;
if (r.nextInt(4) == 2) {
- doRandomOptimize();
+ doRandomForceMerge();
}
if (r.nextBoolean()) {
if (LuceneTestCase.VERBOSE) {
@@ -246,21 +246,21 @@ public class RandomIndexWriter implement
*/
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.
* <p>
* 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);
}
}
Modified: lucene/dev/branches/branch_3x/lucene/src/test-framework/java/org/apache/lucene/index/ThreadedIndexingAndSearchingTestCase.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/branch_3x/lucene/src/test-framework/java/org/apache/lucene/index/ThreadedIndexingAndSearchingTestCase.java?rev=1201265&r1=1201264&r2=1201265&view=diff
==============================================================================
--- lucene/dev/branches/branch_3x/lucene/src/test-framework/java/org/apache/lucene/index/ThreadedIndexingAndSearchingTestCase.java (original)
+++ lucene/dev/branches/branch_3x/lucene/src/test-framework/java/org/apache/lucene/index/ThreadedIndexingAndSearchingTestCase.java Sat Nov 12 14:09:28 2011
@@ -50,7 +50,7 @@ import org.apache.lucene.util.NamedThrea
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
Modified: lucene/dev/branches/branch_3x/lucene/src/test-framework/java/org/apache/lucene/util/LuceneTestCase.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/branch_3x/lucene/src/test-framework/java/org/apache/lucene/util/LuceneTestCase.java?rev=1201265&r1=1201264&r2=1201265&view=diff
==============================================================================
--- lucene/dev/branches/branch_3x/lucene/src/test-framework/java/org/apache/lucene/util/LuceneTestCase.java (original)
+++ lucene/dev/branches/branch_3x/lucene/src/test-framework/java/org/apache/lucene/util/LuceneTestCase.java Sat Nov 12 14:09:28 2011
@@ -30,24 +30,16 @@ import java.util.Map.Entry;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
+
import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.document.Field.Index;
import org.apache.lucene.document.Field.Store;
import org.apache.lucene.document.Field.TermVector;
import org.apache.lucene.document.Field;
-import org.apache.lucene.index.IndexReader;
-import org.apache.lucene.index.IndexWriterConfig;
-import org.apache.lucene.index.LogByteSizeMergePolicy;
-import org.apache.lucene.index.LogDocMergePolicy;
-import org.apache.lucene.index.LogMergePolicy;
-import org.apache.lucene.index.MergePolicy;
-import org.apache.lucene.index.MockRandomMergePolicy;
-import org.apache.lucene.index.SerialMergeScheduler;
-import org.apache.lucene.index.SlowMultiReaderWrapper;
-import org.apache.lucene.index.TieredMergePolicy;
+import org.apache.lucene.index.*;
+import org.apache.lucene.search.AssertingIndexSearcher;
import org.apache.lucene.search.BooleanQuery;
import org.apache.lucene.search.FieldCache.CacheEntry;
-import org.apache.lucene.search.AssertingIndexSearcher;
import org.apache.lucene.search.FieldCache;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.store.Directory;
Modified: lucene/dev/branches/branch_3x/lucene/src/test/org/apache/lucene/TestMergeSchedulerExternal.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/branch_3x/lucene/src/test/org/apache/lucene/TestMergeSchedulerExternal.java?rev=1201265&r1=1201264&r2=1201265&view=diff
==============================================================================
--- lucene/dev/branches/branch_3x/lucene/src/test/org/apache/lucene/TestMergeSchedulerExternal.java (original)
+++ lucene/dev/branches/branch_3x/lucene/src/test/org/apache/lucene/TestMergeSchedulerExternal.java Sat Nov 12 14:09:28 2011
@@ -141,7 +141,7 @@ public class TestMergeSchedulerExternal
writer.commit(); // trigger flush
writer.addDocument(new Document());
writer.commit(); // trigger flush
- writer.optimize();
+ writer.forceMerge(1);
writer.close();
dir.close();
}
Modified: lucene/dev/branches/branch_3x/lucene/src/test/org/apache/lucene/index/Test2BPostings.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/branch_3x/lucene/src/test/org/apache/lucene/index/Test2BPostings.java?rev=1201265&r1=1201264&r2=1201265&view=diff
==============================================================================
--- lucene/dev/branches/branch_3x/lucene/src/test/org/apache/lucene/index/Test2BPostings.java (original)
+++ lucene/dev/branches/branch_3x/lucene/src/test/org/apache/lucene/index/Test2BPostings.java Sat Nov 12 14:09:28 2011
@@ -28,7 +28,6 @@ import org.apache.lucene.index.FieldInfo
import org.apache.lucene.store.MockDirectoryWrapper;
import org.apache.lucene.util.LuceneTestCase;
import org.apache.lucene.util._TestUtil;
-import org.junit.Ignore;
/**
* Test indexes ~82M docs with 26 terms each, so you get > Integer.MAX_VALUE terms/docs pairs
@@ -70,7 +69,7 @@ public class Test2BPostings extends Luce
System.out.println(i + " of " + numDocs + "...");
}
}
- w.optimize();
+ w.forceMerge(1);
w.close();
CheckIndex ci = new CheckIndex(dir);
if (VERBOSE) {
Modified: lucene/dev/branches/branch_3x/lucene/src/test/org/apache/lucene/index/Test2BTerms.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/branch_3x/lucene/src/test/org/apache/lucene/index/Test2BTerms.java?rev=1201265&r1=1201264&r2=1201265&view=diff
==============================================================================
--- lucene/dev/branches/branch_3x/lucene/src/test/org/apache/lucene/index/Test2BTerms.java (original)
+++ lucene/dev/branches/branch_3x/lucene/src/test/org/apache/lucene/index/Test2BTerms.java Sat Nov 12 14:09:28 2011
@@ -24,7 +24,6 @@ import org.apache.lucene.analysis.*;
import org.apache.lucene.analysis.tokenattributes.*;
import org.apache.lucene.document.*;
import org.apache.lucene.index.FieldInfo.IndexOptions;
-import java.io.File;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
@@ -133,8 +132,8 @@ public class Test2BTerms extends LuceneT
}
savedTerms = ts.savedTerms;
- System.out.println("TEST: optimize");
- w.optimize();
+ System.out.println("TEST: full merge");
+ w.forceMerge(1);
System.out.println("TEST: close writer");
w.close();
}
Modified: lucene/dev/branches/branch_3x/lucene/src/test/org/apache/lucene/index/TestAddIndexes.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/branch_3x/lucene/src/test/org/apache/lucene/index/TestAddIndexes.java?rev=1201265&r1=1201264&r2=1201265&view=diff
==============================================================================
--- lucene/dev/branches/branch_3x/lucene/src/test/org/apache/lucene/index/TestAddIndexes.java (original)
+++ lucene/dev/branches/branch_3x/lucene/src/test/org/apache/lucene/index/TestAddIndexes.java Sat Nov 12 14:09:28 2011
@@ -31,12 +31,12 @@ import org.apache.lucene.document.Field.
import org.apache.lucene.document.Field.Store;
import org.apache.lucene.document.Field.TermVector;
import org.apache.lucene.index.IndexWriterConfig.OpenMode;
+import org.apache.lucene.search.PhraseQuery;
import org.apache.lucene.store.AlreadyClosedException;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.MockDirectoryWrapper;
import org.apache.lucene.store.RAMDirectory;
-import org.apache.lucene.search.PhraseQuery;
public class TestAddIndexes extends LuceneTestCase {
@@ -95,7 +95,7 @@ public class TestAddIndexes extends Luce
assertEquals(40, writer.maxDoc());
writer.close();
- // test doc count before segments are merged/index is optimized
+ // test doc count before segments are merged
writer = newWriter(dir, newIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(random)).setOpenMode(OpenMode.APPEND));
assertEquals(190, writer.maxDoc());
writer.addIndexes(new Directory[] { aux3 });
@@ -109,9 +109,9 @@ public class TestAddIndexes extends Luce
verifyTermDocs(dir, new Term("content", "bbb"), 50);
- // now optimize it.
+ // now fully merge it.
writer = newWriter(dir, newIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(random)).setOpenMode(OpenMode.APPEND));
- writer.optimize();
+ writer.forceMerge(1);
writer.close();
// make sure the new index is correct
@@ -170,7 +170,7 @@ public class TestAddIndexes extends Luce
q.add(new Term("content", "14"));
writer.deleteDocuments(q);
- writer.optimize();
+ writer.forceMerge(1);
writer.commit();
verifyNumDocs(dir, 1039);
@@ -207,7 +207,7 @@ public class TestAddIndexes extends Luce
q.add(new Term("content", "14"));
writer.deleteDocuments(q);
- writer.optimize();
+ writer.forceMerge(1);
writer.commit();
verifyNumDocs(dir, 1039);
@@ -246,7 +246,7 @@ public class TestAddIndexes extends Luce
writer.addIndexes(new Directory[] {aux});
- writer.optimize();
+ writer.forceMerge(1);
writer.commit();
verifyNumDocs(dir, 1039);
@@ -715,10 +715,10 @@ public class TestAddIndexes extends Luce
switch(j%5) {
case 0:
if (VERBOSE) {
- System.out.println(Thread.currentThread().getName() + ": TEST: addIndexes(Dir[]) then optimize");
+ System.out.println(Thread.currentThread().getName() + ": TEST: addIndexes(Dir[]) then full merge");
}
writer2.addIndexes(dirs);
- writer2.optimize();
+ writer2.forceMerge(1);
break;
case 1:
if (VERBOSE) {
@@ -821,10 +821,10 @@ public class TestAddIndexes extends Luce
switch(j%5) {
case 0:
if (VERBOSE) {
- System.out.println("TEST: " + Thread.currentThread().getName() + ": addIndexes + optimize");
+ System.out.println("TEST: " + Thread.currentThread().getName() + ": addIndexes + full merge");
}
writer2.addIndexes(dirs);
- writer2.optimize();
+ writer2.forceMerge(1);
break;
case 1:
if (VERBOSE) {
@@ -840,9 +840,9 @@ public class TestAddIndexes extends Luce
break;
case 3:
if (VERBOSE) {
- System.out.println("TEST: " + Thread.currentThread().getName() + ": optimize");
+ System.out.println("TEST: " + Thread.currentThread().getName() + ": full merge");
}
- writer2.optimize();
+ writer2.forceMerge(1);
break;
case 4:
if (VERBOSE) {
@@ -1044,5 +1044,4 @@ public class TestAddIndexes extends Luce
src.close();
target.close();
}
-
}