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

Finding current android device location

A Rectangle specifies an area in a coordinate space that is enclosed by the 
Rectangle object's top-

java.awt.Rectangle

An URLConnection for HTTP (RFC 2616 [http://tools.ietf.org/html/rfc2616]) used
to send and receive d

java.net.HttpURLConnection

HashMap is an implementation of Map. All optional operations are supported.All
elements are permitte

java.util.HashMap

This class provides access to implementations of cryptographic ciphers for
encryption and decryption

javax.crypto.Cipher

Defines a general exception a servlet can throw when it encounters difficulty.

javax.servlet.ServletException

javax.swing.JComboBox

scheduleAtFixedRate

startActivity

getResourceAsStream

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