## org.apache.lucene.index
Class MergePolicy

    java.lang.Object
      org.apache.lucene.index.MergePolicy

Direct Known Subclasses:
  LogMergePolicy

    public abstract class MergePolicy

extends java.lang.Object

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 `IndexWriter`, either the addition of a newly flushed segment, addition of many segments from addIndexes* calls, or a previous merge that may now need to cascade, `IndexWriter` invokes `findMerges(org.apache.lucene.index.SegmentInfos)` to give the MergePolicy a chance to pick merges that are now required. This method returns a `MergePolicy.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 `findMergesForOptimize(org.apache.lucene.index.SegmentInfos, int, java.util.Set)` and the MergePolicy should then return the necessary merges.

Note that the policy can return more than one merge at a time. In this case, if the writer is using `SerialMergeScheduler`, the merges will be run sequentially but if it is using `ConcurrentMergeScheduler` they will be run concurrently.

The default MergePolicy is `LogByteSizeMergePolicy`.

NOTE: This API is new and still experimental (subject to change suddenly in the next release)

NOTE: This class typically requires access to package-private APIs (e.g. `SegmentInfos`) to do its job; if you implement your own MergePolicy, you'll need to put it in package org.apache.lucene.index in order to use these APIs.

Nested Class Summary
`static class` `MergePolicy.MergeAbortedException`
`static class` `MergePolicy.MergeException` Exception thrown if there are any problems while executing a merge.
`static class` `MergePolicy.MergeSpecification` A MergeSpecification instance provides the information necessary to perform multiple merges.
`static class` `MergePolicy.OneMerge` OneMerge provides the information necessary to perform an individual primitive merge operation, resulting in a single new segment.

Field Summary
`protected IndexWriter` `writer`

Constructor Summary
`MergePolicy(IndexWriter writer)`

Method Summary
`abstract void` `close()` Release all resources for the policy.
`abstract MergePolicy.MergeSpecification` `findMerges(SegmentInfos segmentInfos)` Determine what set of merge operations are now necessary on the index.
`abstract MergePolicy.MergeSpecification` `findMergesForOptimize(SegmentInfos segmentInfos, int maxSegmentCount, java.util.Set segmentsToOptimize)` Determine what set of merge operations is necessary in order to optimize the index.
`abstract MergePolicy.MergeSpecification` `findMergesToExpungeDeletes(SegmentInfos segmentInfos)` Determine what set of merge operations is necessary in order to expunge all deletes from the index.
`abstract boolean` `useCompoundDocStore(SegmentInfos segments)` Returns true if the doc store files should use the compound file format.
`abstract boolean` `useCompoundFile(SegmentInfos segments, SegmentInfo newSegment)` Returns true if a newly flushed (not from merge) segment should use the compound file format.

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### writer

    protected final IndexWriter writer

Constructor Detail

### MergePolicy

    public MergePolicy(IndexWriter writer)

Method Detail

### findMerges

    public abstract MergePolicy.MergeSpecification findMerges(SegmentInfos segmentInfos)
                                                       throws CorruptIndexException,
                                                              java.io.IOException

  Determine what set of merge operations are now necessary on the index. `IndexWriter` calls this whenever there is a change to the segments. This call is always synchronized on the `IndexWriter` instance so only one thread at a time will call this method.

  Parameters:
    `segmentInfos` - the total set of segments in the index
  Throws:
    `CorruptIndexException`
    `java.io.IOException`

### findMergesForOptimize

    public abstract MergePolicy.MergeSpecification findMergesForOptimize(SegmentInfos segmentInfos,
                                                                         int maxSegmentCount,
                                                                         java.util.Set segmentsToOptimize)
                                                                  throws CorruptIndexException,
                                                                         java.io.IOException

  Determine what set of merge operations is necessary in order to optimize the index. `IndexWriter` calls this when its `IndexWriter.optimize()` method is called. This call is always synchronized on the `IndexWriter` instance so only one thread at a time will call this method.

  Parameters:
    `segmentInfos` - the total set of segments in the index
    `maxSegmentCount` - requested maximum number of segments in the index (currently this is always 1)
    `segmentsToOptimize` - contains the specific SegmentInfo instances that must be merged away. This may be a subset of all SegmentInfos.
  Throws:
    `CorruptIndexException`
    `java.io.IOException`

### findMergesToExpungeDeletes

    public abstract MergePolicy.MergeSpecification findMergesToExpungeDeletes(SegmentInfos segmentInfos)
                                                                       throws CorruptIndexException,
                                                                              java.io.IOException

  Determine what set of merge operations is necessary in order to expunge all deletes from the index.

  Parameters:
    `segmentInfos` - the total set of segments in the index
  Throws:
    `CorruptIndexException`
    `java.io.IOException`

### close

    public abstract void close()

  Release all resources for the policy.

### useCompoundFile

    public abstract boolean useCompoundFile(SegmentInfos segments,
                                            SegmentInfo newSegment)

  Returns true if a newly flushed (not from merge) segment should use the compound file format.

### useCompoundDocStore

    public abstract boolean useCompoundDocStore(SegmentInfos segments)

  Returns true if the doc store files should use the compound file format.

Copyright © 2000-2011 Apache Software Foundation. All Rights Reserved.