Show / Hide Table of Contents

    Class LiveIndexWriterConfig

    Holds all the configuration used by IndexWriter with few setters for settings that can be changed on an IndexWriter instance "live".

    @since 4.0

    Inheritance
    System.Object
    LiveIndexWriterConfig
    IndexWriterConfig
    Namespace: Lucene.Net.Index
    Assembly: Lucene.Net.dll
    Syntax
    public class LiveIndexWriterConfig : object

    Properties

    | Improve this Doc View Source

    Analyzer

    Gets the default analyzer to use for indexing documents.

    Declaration
    public virtual Analyzer Analyzer { get; }
    Property Value
    Type Description
    Analyzer
    | Improve this Doc View Source

    CheckIntegrityAtMerge

    Gets or sets if IndexWriter should call CheckIntegrity() on existing segments before merging them into a new one.

    Use true to enable this safety check, which can help reduce the risk of propagating index corruption from older segments into new ones, at the expense of slower merging.

    Declaration
    public virtual bool CheckIntegrityAtMerge { get; set; }
    Property Value
    Type Description
    System.Boolean
    | Improve this Doc View Source

    Codec

    Returns the current Codec.

    Declaration
    public virtual Codec Codec { get; }
    Property Value
    Type Description
    Codec
    | Improve this Doc View Source

    IndexCommit

    Gets the IndexCommit as specified in IndexCommit setter or the default, null which specifies to open the latest index commit point.

    Declaration
    public virtual IndexCommit IndexCommit { get; }
    Property Value
    Type Description
    IndexCommit
    | Improve this Doc View Source

    IndexDeletionPolicy

    Gets the IndexDeletionPolicy specified in IndexDeletionPolicy setter or the default KeepOnlyLastCommitDeletionPolicy

    Declaration
    public virtual IndexDeletionPolicy IndexDeletionPolicy { get; }
    Property Value
    Type Description
    IndexDeletionPolicy
    | Improve this Doc View Source

    InfoStream

    Returns InfoStream used for debugging.

    Declaration
    public virtual InfoStream InfoStream { get; }
    Property Value
    Type Description
    InfoStream
    See Also
    SetInfoStream(InfoStream)
    | Improve this Doc View Source

    MaxBufferedDeleteTerms

    Gets or sets a value that determines the maximum number of delete-by-term operations that will be buffered before both the buffered in-memory delete terms and queries are applied and flushed.

    Disabled by default (writer flushes by RAM usage).

    NOTE: this setting won't trigger a segment flush.

    Takes effect immediately, but only the next time a document is added, updated or deleted. Also, if you only delete-by-query, this setting has no effect, i.e. delete queries are buffered until the next segment is flushed.

    Declaration
    public virtual int MaxBufferedDeleteTerms { get; set; }
    Property Value
    Type Description
    System.Int32
    See Also
    RAMBufferSizeMB
    | Improve this Doc View Source

    MaxBufferedDocs

    Gets or sets a value that determines the minimal number of documents required before the buffered in-memory documents are flushed as a new Segment. Large values generally give faster indexing.

    When this is set, the writer will flush every maxBufferedDocs added documents. Pass in DISABLE_AUTO_FLUSH to prevent triggering a flush due to number of buffered documents. Note that if flushing by RAM usage is also enabled, then the flush will be triggered by whichever comes first.

    Disabled by default (writer flushes by RAM usage).

    Takes effect immediately, but only the next time a document is added, updated or deleted.

    Declaration
    public virtual int MaxBufferedDocs { get; set; }
    Property Value
    Type Description
    System.Int32
    See Also
    RAMBufferSizeMB
    | Improve this Doc View Source

    MaxThreadStates

    Returns the max number of simultaneous threads that may be indexing documents at once in IndexWriter.

    Declaration
    public virtual int MaxThreadStates { get; }
    Property Value
    Type Description
    System.Int32
    | Improve this Doc View Source

    MergedSegmentWarmer

    Gets or sets the merged segment warmer. See IndexWriter.IndexReaderWarmer.

    Takes effect on the next merge.

    Declaration
    public virtual IndexWriter.IndexReaderWarmer MergedSegmentWarmer { get; set; }
    Property Value
    Type Description
    IndexWriter.IndexReaderWarmer
    | Improve this Doc View Source

    MergePolicy

    Returns the current MergePolicy in use by this writer.

    Declaration
    public virtual MergePolicy MergePolicy { get; }
    Property Value
    Type Description
    MergePolicy
    See Also
    MergePolicy
    | Improve this Doc View Source

    MergeScheduler

    Returns the IMergeScheduler that was set by MergeScheduler setter.

    Declaration
    public virtual IMergeScheduler MergeScheduler { get; }
    Property Value
    Type Description
    IMergeScheduler
    | Improve this Doc View Source

    OpenMode

    Gets the OpenMode set by OpenMode setter.

    Declaration
    public virtual OpenMode OpenMode { get; }
    Property Value
    Type Description
    OpenMode
    | Improve this Doc View Source

    RAMBufferSizeMB

    Gets or sets a value that determines the amount of RAM that may be used for buffering added documents and deletions before they are flushed to the Directory. Generally for faster indexing performance it's best to flush by RAM usage instead of document count and use as large a RAM buffer as you can.

    When this is set, the writer will flush whenever buffered documents and deletions use this much RAM. Pass in DISABLE_AUTO_FLUSH to prevent triggering a flush due to RAM usage. Note that if flushing by document count is also enabled, then the flush will be triggered by whichever comes first.

    The maximum RAM limit is inherently determined by the runtime's available memory. Yet, an IndexWriter session can consume a significantly larger amount of memory than the given RAM limit since this limit is just an indicator when to flush memory resident documents to the Directory. Flushes are likely happen concurrently while other threads adding documents to the writer. For application stability the available memory in the runtime should be significantly larger than the RAM buffer used for indexing.

    NOTE: the account of RAM usage for pending deletions is only approximate. Specifically, if you delete by Query, Lucene currently has no way to measure the RAM usage of individual Queries so the accounting will under-estimate and you should compensate by either calling Commit() periodically yourself, or by setting MaxBufferedDeleteTerms to flush and apply buffered deletes by count instead of RAM usage (for each buffered delete Query a constant number of bytes is used to estimate RAM usage). Note that enabling MaxBufferedDeleteTerms will not trigger any segment flushes.

    NOTE: It's not guaranteed that all memory resident documents are flushed once this limit is exceeded. Depending on the configured Lucene.Net.Index.LiveIndexWriterConfig.FlushPolicy only a subset of the buffered documents are flushed and therefore only parts of the RAM buffer is released.

    The default value is DEFAULT_RAM_BUFFER_SIZE_MB.

    Takes effect immediately, but only the next time a document is added, updated or deleted.

    Declaration
    public virtual double RAMBufferSizeMB { get; set; }
    Property Value
    Type Description
    System.Double
    See Also
    RAMPerThreadHardLimitMB
    | Improve this Doc View Source

    RAMPerThreadHardLimitMB

    Returns the max amount of memory each Lucene.Net.Index.DocumentsWriterPerThread can consume until forcefully flushed.

    Declaration
    public virtual int RAMPerThreadHardLimitMB { get; }
    Property Value
    Type Description
    System.Int32
    See Also
    RAMPerThreadHardLimitMB
    | Improve this Doc View Source

    ReaderTermsIndexDivisor

    Gets or sets the termsIndexDivisor passed to any readers that IndexWriter opens, for example when applying deletes or creating a near-real-time reader in Open(IndexWriter, Boolean). If you pass -1, the terms index won't be loaded by the readers. This is only useful in advanced situations when you will only .Next() through all terms; attempts to seek will hit an exception.

    Takes effect immediately, but only applies to readers opened after this call

    NOTE: divisor settings > 1 do not apply to all PostingsFormat implementations, including the default one in this release. It only makes sense for terms indexes that can efficiently re-sample terms at load time.

    Declaration
    public virtual int ReaderTermsIndexDivisor { get; set; }
    Property Value
    Type Description
    System.Int32
    | Improve this Doc View Source

    Similarity

    Expert: returns the Similarity implementation used by this IndexWriter.

    Declaration
    public virtual Similarity Similarity { get; }
    Property Value
    Type Description
    Similarity
    | Improve this Doc View Source

    TermIndexInterval

    Expert: Gets or sets the interval between indexed terms. Large values cause less memory to be used by IndexReader, but slow random-access to terms. Small values cause more memory to be used by an IndexReader, and speed random-access to terms.

    This parameter determines the amount of computation required per query term, regardless of the number of documents that contain that term. In particular, it is the maximum number of other terms that must be scanned before a term is located and its frequency and position information may be processed. In a large index with user-entered query terms, query processing time is likely to be dominated not by term lookup but rather by the processing of frequency and positional data. In a small index or when many uncommon query terms are generated (e.g., by wildcard queries) term lookup may become a dominant cost.

    In particular, numUniqueTerms/interval terms are read into memory by an IndexReader, and, on average, interval/2 terms must be scanned for each random term access.

    Takes effect immediately, but only applies to newly flushed/merged segments.

    NOTE: this parameter does not apply to all PostingsFormat implementations, including the default one in this release. It only makes sense for term indexes that are implemented as a fixed gap between terms. For example, Lucene41PostingsFormat implements the term index instead based upon how terms share prefixes. To configure its parameters (the minimum and maximum size for a block), you would instead use Lucene41PostingsFormat(Int32, Int32). which can also be configured on a per-field basis:

    public class MyLucene45Codec : Lucene45Codec
    {
        //customize Lucene41PostingsFormat, passing minBlockSize=50, maxBlockSize=100
        private readonly PostingsFormat tweakedPostings = new Lucene41PostingsFormat(50, 100);
    
        public override PostingsFormat GetPostingsFormatForField(string field)
        {
            if (field.Equals("fieldWithTonsOfTerms", StringComparison.Ordinal))
                return tweakedPostings;
            else
                return base.GetPostingsFormatForField(field);
        }
    }
    ...
    
    iwc.Codec = new MyLucene45Codec();

    Note that other implementations may have their own parameters, or no parameters at all.

    Declaration
    public virtual int TermIndexInterval { get; set; }
    Property Value
    Type Description
    System.Int32
    See Also
    DEFAULT_TERM_INDEX_INTERVAL
    | Improve this Doc View Source

    UseCompoundFile

    Gets or sets if the IndexWriter should pack newly written segments in a compound file. Default is true.

    Use false for batch indexing with very large RAM buffer settings.

    Note: To control compound file usage during segment merges see NoCFSRatio and MaxCFSSegmentSizeMB. This setting only applies to newly created segments.

    Declaration
    public virtual bool UseCompoundFile { get; set; }
    Property Value
    Type Description
    System.Boolean
    | Improve this Doc View Source

    UseReaderPooling

    Returns true if IndexWriter should pool readers even if Open(IndexWriter, Boolean) has not been called.

    Declaration
    public virtual bool UseReaderPooling { get; }
    Property Value
    Type Description
    System.Boolean
    | Improve this Doc View Source

    WriteLockTimeout

    Returns allowed timeout when acquiring the write lock.

    Declaration
    public virtual long WriteLockTimeout { get; }
    Property Value
    Type Description
    System.Int64
    See Also
    WriteLockTimeout

    Methods

    | Improve this Doc View Source

    ToString()

    Declaration
    public override string ToString()
    Returns
    Type Description
    System.String

    Extension Methods

    IndexWriterConfigExtensions.SetTermIndexInterval(LiveIndexWriterConfig, Int32)
    IndexWriterConfigExtensions.SetMaxBufferedDeleteTerms(LiveIndexWriterConfig, Int32)
    IndexWriterConfigExtensions.SetRAMBufferSizeMB(LiveIndexWriterConfig, Double)
    IndexWriterConfigExtensions.SetMaxBufferedDocs(LiveIndexWriterConfig, Int32)
    IndexWriterConfigExtensions.SetMergedSegmentWarmer(LiveIndexWriterConfig, IndexWriter.IndexReaderWarmer)
    IndexWriterConfigExtensions.SetReaderTermsIndexDivisor(LiveIndexWriterConfig, Int32)
    IndexWriterConfigExtensions.SetUseCompoundFile(LiveIndexWriterConfig, Boolean)
    IndexWriterConfigExtensions.SetCheckIntegrityAtMerge(LiveIndexWriterConfig, Boolean)
    • Improve this Doc
    • View Source
    Back to top Copyright © 2020 Licensed to the Apache Software Foundation (ASF)