Package org.apache.lucene.index

Class LogMergePolicy

    • Field Detail

      • LEVEL_LOG_SPAN

        public static final double LEVEL_LOG_SPAN
        Defines the allowed range of log(size) for each level. A level is computed by taking the max segment log size, minus LEVEL_LOG_SPAN, and finding all segments falling within that range.
        See Also:
        Constant Field Values

      • DEFAULT_MERGE_FACTOR

        public static final int DEFAULT_MERGE_FACTOR
        Default merge factor, which is how many segments are merged at a time
        See Also:
        Constant Field Values

      • DEFAULT_MAX_MERGE_DOCS

        public static final int DEFAULT_MAX_MERGE_DOCS
        Default maximum segment size. A segment of this size or larger will never be merged. @see setMaxMergeDocs
        See Also:
        Constant Field Values

      • DEFAULT_NO_CFS_RATIO

        public static final double DEFAULT_NO_CFS_RATIO
        Default noCFSRatio. If a merge's size is >= 10% of the index, then we disable compound file for it.
        See Also:
        setNoCFSRatio(double), Constant Field Values

      • mergeFactor

        protected int mergeFactor

      • minMergeSize

        protected long minMergeSize

      • maxMergeSize

        protected long maxMergeSize

      • maxMergeSizeForForcedMerge

        protected long maxMergeSizeForForcedMerge

      • maxMergeDocs

        protected int maxMergeDocs

      • noCFSRatio

        protected double noCFSRatio

      • calibrateSizeByDeletes

        protected boolean calibrateSizeByDeletes

      • useCompoundFile

        protected boolean useCompoundFile

    • Constructor Detail

      • LogMergePolicy

        public LogMergePolicy()

    • Method Detail

      • verbose

        protected boolean verbose()

      • setNoCFSRatio

        public void setNoCFSRatio​(double noCFSRatio)
        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.

      • message

        protected void message​(String message)

      • getMergeFactor

        public int getMergeFactor()

        Returns the number of segments that are merged at once and also controls the total number of segments allowed to accumulate in the index.

      • setMergeFactor

        public void setMergeFactor​(int mergeFactor)
        Determines how often segment indices are merged by addDocument(). With smaller values, less RAM is used while indexing, and searches are faster, but indexing speed is slower. With larger values, more RAM is used during indexing, and while 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.

      • setUseCompoundFile

        public void setUseCompoundFile​(boolean useCompoundFile)
        Sets whether compound file format should be used for newly flushed and newly merged segments.

      • getUseCompoundFile

        public boolean getUseCompoundFile()
        Returns true if newly flushed and newly merge segments are written in compound file format. @see #setUseCompoundFile

      • setCalibrateSizeByDeletes

        public void setCalibrateSizeByDeletes​(boolean calibrateSizeByDeletes)
        Sets whether the segment size should be calibrated by the number of deletes when choosing segments for merge.

      • getCalibrateSizeByDeletes

        public boolean getCalibrateSizeByDeletes()
        Returns true if the segment size should be calibrated by the number of deletes when choosing segments for merge.

      • isMerged

        protected boolean isMerged​(SegmentInfo info)
                    throws IOException
        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
        Throws:
        IOException

      • findForcedMerges

        public MergePolicy.MergeSpecification findForcedMerges​(SegmentInfos infos,
                                                       int maxNumSegments,
                                                       Map<SegmentInfo,​Boolean> segmentsToMerge)
                                                throws IOException
        Returns the merges necessary to merge the index down to a specified number of segments. This respects the maxMergeSizeForForcedMerge setting. By default, and assuming 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 compound file format if the current useCompoundFile setting is true. This method returns multiple merges (mergeFactor at a time) so the MergeScheduler in use may make use of concurrency.
        Specified by:
        findForcedMerges in class MergePolicy
        Parameters:
        infos - the total set of segments in the index
        maxNumSegments - 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.
        Throws:
        IOException

      • setMaxMergeDocs

        public void setMaxMergeDocs​(int maxMergeDocs)

        Determines the largest segment (measured by document count) that may be merged with other segments. Small values (e.g., less than 10,000) are best for interactive indexing, as this limits the length of pauses while indexing to a few seconds. Larger values are best for batched indexing and speedier searches.

        The default value is Integer.MAX_VALUE.

        The default merge policy (LogByteSizeMergePolicy) also allows you to set this limit by net size (in MB) of the segment, using LogByteSizeMergePolicy.setMaxMergeMB(double).

      • getMaxMergeDocs

        public int getMaxMergeDocs()
        Returns the largest segment (measured by document count) that may be merged with other segments.
        See Also:
        setMaxMergeDocs(int)