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

Making http requests using okhttp

Wraps an existing Writer and buffers the output. Expensive interaction with the
underlying reader is

java.io.BufferedWriter

An output stream that writes bytes to a file. If the output file exists, it can
be replaced or appen

java.io.FileOutputStream

 Collection is the root of the collection hierarchy. It defines operations on
data collections and t

java.util.Collection

 JarFile is used to read jar entries and their associated data from jar files.

java.util.jar.JarFile

javax.swing.JLabel

Used to perform Get operations on a single row. To get everything for a row,
instantiate a Get objec

org.apache.hadoop.hbase.client.Get

getSupportFragmentManager

getSharedPreferences

getExternalFilesDir

/**
   * 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