Public

<init>

Merges the readers specified by the #add method into the directory passed to the
constructor.

merge

mergeFields

mergeNorms

mergeTerms

Merge the TermVectors from each of the segments into the new one.

mergeVectors

mergeDocValues

mergeFieldInfos

shouldMerge

Add an IndexReader to the collection of readers that are to be merged

Process postings from multiple segments all positioned on the same term. Writes
out merged entries i

appendPostings

close all IndexReaders that have been added. Should not be called before
merge().

closeReaders

createCompoundFile

Merge one term found in one or more segments. The array smis contains segments
that are positioned a

mergeTermInfo

mergeTermInfos

addIndexed

Process postings from multiple segments without tf, all positioned on the same
term. Writes out merg

appendPostingsNoTf

getDelCounts

getDocMaps

hasProx

StringBuilder

Reactive rest calls using spring rest template

The Font class represents fonts, which are used to render text in a visible way.
A font provides the

java.awt.Font

A java.util.Queue that additionally supports operations that wait for the queue
to become non-empty 

java.util.concurrent.BlockingQueue

The annotation structure.An instance of this class is returned bygetAnnotations() in AnnotationsAttr

javassist.bytecode.annotation.Annotation

Extends the javax.servlet.ServletRequest interface to provide request
information for HTTP servlets.

javax.servlet.http.HttpServletRequest

javax.swing.BoxLayout

The LoggerFactory is a utility class producing Loggers for various logging APIs,
most notably for lo

org.slf4j.LoggerFactory

putExtra

setRequestProperty

startActivity

/**
   * Merges the readers specified by the {@link #add} method into the directory passed to the constructor
   * @return The number of documents that were merged
   * @throws IOException
   */

/** Does the actual (time-consuming) work of the merge,
   *  but without holding synchronized lock on IndexWriter
   *  instance */

// This is try/finally to make sure merger's readers are

// close readers before we attempt to delete

// commitMerge will return false if this merge was aborted

// Maybe force a sync here to allow reclaiming of the

// disk space used by the segments we just merged:

// This can happen if rollback or close(false)

// is called -- fall through to logic below to

"hit exception creating compound file during merge"

// Our segment (committed in non-compound

// Force a sync after commiting the merge.  Once this

// sync completes then all index files referenced by the

// current segmentInfos are on stable storage so if the

// OS/machine crashes, or power cord is yanked, the

// index will be intact.  Note that this is just one

// (somewhat arbitrary) policy; we could try other

// policies like only sync if it's been > X minutes or

// more than Y bytes have been written, etc.

/** Merges the provided indexes into this index.
 * After this completes, the index is optimized. 
 * The provided IndexReaders are not closed.

 * NOTE: the index in each Directory must not be
 * changed (opened by a writer) while this method is
 * running. This method does not acquire a write lock in
 * each input Directory, so it is up to the caller to
 * enforce this.
 *
 * NOTE: while this is running, any attempts to
 * add or delete documents (with another thread) will be
 * paused until this method completes.
 *
 * See {@link #addIndexesNoOptimize(Directory[])} for
 * details on transactional semantics, temporary free
 * space required in the Directory, and non-CFS segments
 * on an Exception.
 * @throws CorruptIndexException if the index is corrupt
 * @throws IOException if there is a low-level IO error
 */

// Do not allow add docs or deletes while we are running:

// We must pre-acquire a read lock here (and upgrade to

// write lock in startTransaction below) so that no

// other addIndexes is allowed to start up after we have

// flushed & optimized but before we then start our

// transaction.  This is because the merging below

// requires that only one segment is present in the

// Take care to release the read lock if we hit an

// exception before starting the transaction

// true means we already have a read lock; if this

// call hits an exception it will release the write

// Notify DocumentsWriter that the flushed count just increased

"hit exception in addIndexes during merge"

// Must incRef our files so that if another thread

// is running merge/optimize, it doesn't delete our

// segment's files before we have a change to

"hit exception building compound file in addIndexes during merge"

How to use createCompoundFilemethodin org.apache.lucene.index.SegmentMerger

Best Java code snippets using org.apache.lucene.index.SegmentMerger.createCompoundFile (Showing top 5 results out of 315)

How to use
createCompoundFile
method
in
org.apache.lucene.index.SegmentMerger