Class NoMergePolicy


  • public final class NoMergePolicy
    extends MergePolicy
    A MergePolicy which never returns merges to execute. Use it if you want to prevent segment merges.
    • Field Detail

      • INSTANCE

        public static final MergePolicy INSTANCE
        Singleton instance.
    • Constructor Detail

      • NoMergePolicy

        private NoMergePolicy()
    • Method Detail

      • findMerges

        public MergePolicy.MergeSpecification findMerges​(MergeTrigger mergeTrigger,
                                                         SegmentInfos segmentInfos,
                                                         MergePolicy.MergeContext mergeContext)
        Description copied from class: MergePolicy
        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.
        Specified by:
        findMerges in class MergePolicy
        Parameters:
        mergeTrigger - the event that triggered the merge
        segmentInfos - the total set of segments in the index
        mergeContext - the IndexWriter to find the merges on
      • findForcedMerges

        public MergePolicy.MergeSpecification findForcedMerges​(SegmentInfos segmentInfos,
                                                               int maxSegmentCount,
                                                               java.util.Map<SegmentCommitInfo,​java.lang.Boolean> segmentsToMerge,
                                                               MergePolicy.MergeContext mergeContext)
        Description copied from class: MergePolicy
        Determine what set of merge operations is necessary in order to merge to <= the specified segment count. IndexWriter calls this when its IndexWriter.forceMerge(int) method is called. This call is always synchronized on the IndexWriter instance so only one thread at a time will call this method.
        Specified by:
        findForcedMerges in class MergePolicy
        Parameters:
        segmentInfos - the total set of segments in the index
        maxSegmentCount - requested maximum number of segments in the index (currently this is always 1)
        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-merged index; else, it was a segment produced by a cascaded merge.
        mergeContext - the IndexWriter to find the merges on
      • getMaxCFSSegmentSizeMB

        public double getMaxCFSSegmentSizeMB()
        Description copied from class: MergePolicy
        Returns the largest size allowed for a compound file segment
        Overrides:
        getMaxCFSSegmentSizeMB in class MergePolicy
      • setMaxCFSSegmentSizeMB

        public void setMaxCFSSegmentSizeMB​(double v)
        Description copied from class: MergePolicy
        If a merged segment will be more than this value, leave the segment as non-compound file even if compound file is enabled. Set this to Double.POSITIVE_INFINITY (default) and noCFSRatio to 1.0 to always use CFS regardless of merge size.
        Overrides:
        setMaxCFSSegmentSizeMB in class MergePolicy
      • setNoCFSRatio

        public void setNoCFSRatio​(double noCFSRatio)
        Description copied from class: MergePolicy
        If a merged segment will be more than this percentage of the total size of the index, leave the segment as non-compound file even if compound file is enabled. Set to 1.0 to always use CFS regardless of merge size.
        Overrides:
        setNoCFSRatio in class MergePolicy
      • keepFullyDeletedSegment

        public boolean keepFullyDeletedSegment​(IOSupplier<CodecReader> readerIOSupplier)
                                        throws java.io.IOException
        Description copied from class: MergePolicy
        Returns true if the segment represented by the given CodecReader should be keep even if it's fully deleted. This is useful for testing of for instance if the merge policy implements retention policies for soft deletes.
        Overrides:
        keepFullyDeletedSegment in class MergePolicy
        Throws:
        java.io.IOException
      • numDeletesToMerge

        public int numDeletesToMerge​(SegmentCommitInfo info,
                                     int delCount,
                                     IOSupplier<CodecReader> readerSupplier)
                              throws java.io.IOException
        Description copied from class: MergePolicy
        Returns the number of deletes that a merge would claim on the given segment. This method will by default return the sum of the del count on disk and the pending delete count. Yet, subclasses that wrap merge readers might modify this to reflect deletes that are carried over to the target segment in the case of soft deletes. Soft deletes all deletes to survive across merges in order to control when the soft-deleted data is claimed.
        Overrides:
        numDeletesToMerge in class MergePolicy
        Parameters:
        info - the segment info that identifies the segment
        delCount - the number deleted documents for this segment
        readerSupplier - a supplier that allows to obtain a CodecReader for this segment
        Throws:
        java.io.IOException
        See Also:
        IndexWriter.softUpdateDocument(Term, Iterable, Field...), IndexWriterConfig.setSoftDeletesField(String)
      • toString

        public java.lang.String toString()
        Overrides:
        toString in class java.lang.Object