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

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `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

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected IndexWriter` | `writer`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `MergePolicy(IndexWriter writer)`

  - ### Method Summary

    All Methods Instance Methods Abstract Methods
    Modifier and Type | Method and Description
    --- | ---
    `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-2016 Apache Software Foundation. All Rights Reserved.