InternalEngine (Elasticsearch: Core 2.3.5.1 API)

java.lang.Object
- org.elasticsearch.index.engine.Engine
- - org.elasticsearch.index.engine.InternalEngine

すべての実装されたインタフェース:

Closeable, AutoCloseable
```
public class InternalEngine
extends Engine
```

ネストされたクラスのサマリー
- クラスから継承されたネストされたクラス/インタフェース org.elasticsearch.index.engine.Engine
  Engine.CommitId, Engine.Create, Engine.Delete, Engine.DeleteByQuery, Engine.FailedEngineListener, Engine.Get, Engine.GetResult, Engine.Index, Engine.IndexingOperation, Engine.IndexThrottle, Engine.NoOpLock, Engine.Operation, Engine.Searcher, Engine.SyncedFlushResult

フィールドのサマリー
- クラスから継承されたフィールド org.elasticsearch.index.engine.Engine
  deletionPolicy, engineConfig, failedEngine, failedEngineListener, failEngineLock, isClosed, logger, readLock, rwl, shardId, store, SYNC_COMMIT_ID, writeLock

コンストラクタのサマリー

コンストラクタ
コンストラクタと説明

InternalEngine(EngineConfig engineConfig, boolean skipInitialTranslogRecovery)

コンストラクタ
コンストラクタと説明
`InternalEngine(EngineConfig engineConfig, boolean skipInitialTranslogRecovery)`

メソッドのサマリー

すべてのメソッドインスタンス・メソッド concreteメソッド非推奨のメソッド
修飾子とタイプ	メソッドと説明
`void`	`activateThrottling()`
`protected void`	`closeNoLock(String reason)` Closes the engine without acquiring the write lock.
`void`	`create(Engine.Create create)`
`void`	`deactivateThrottling()`
`void`	`delete(Engine.Delete delete)`
`void`	`delete(Engine.DeleteByQuery delete)` 非推奨です。 This was removed, but we keep this API so translog can replay any DBQs on upgrade.
`Engine.CommitId`	`flush()` Flushes the state of the engine including the transaction log, clearing memory and persisting documents in the lucene index to disk including a potentially heavy and durable fsync operation.
`Engine.CommitId`	`flush(boolean force, boolean waitIfOngoing)` Flushes the state of the engine including the transaction log, clearing memory.
`void`	`forceMerge(boolean flush, int maxNumSegments, boolean onlyExpungeDeletes, boolean upgrade, boolean upgradeOnlyAncientSegments)` Triggers a forced merge on this engine
`Engine.GetResult`	`get(Engine.Get get)`
`protected org.apache.lucene.index.SegmentInfos`	`getLastCommittedSegmentInfos()`
`MergeStats`	`getMergeStats()`
`protected org.apache.lucene.search.SearcherManager`	`getSearcherManager()`
`Translog`	`getTranslog()` returns the translog for this engine
`boolean`	`hasUncommittedChanges()` Returns `true` the internal writer has any uncommitted changes.
`boolean`	`index(Engine.Index index)`
`long`	`indexWriterRAMBytesUsed()` How much heap Lucene's IndexWriter is using
`protected boolean`	`maybeFailEngine(String source, Throwable t)` Check whether the engine should be failed
`void`	`onSettingsChanged()`
`protected void`	`recoverFromTranslog(EngineConfig engineConfig, Translog.TranslogGeneration translogGeneration)`
`void`	`refresh(String source)` Refreshes the engine for new search operations to reflect the latest changes.
`List<Segment>`	`segments(boolean verbose)` The list of segments in the engine.
`SnapshotIndexCommit`	`snapshotIndex(boolean flushFirst)` Snapshots the index and returns a handle to it.
`Engine.SyncedFlushResult`	`syncFlush(String syncId, Engine.CommitId expectedCommitId)` Attempts to do a special commit where the given syncID is put into the commit data.
`protected void`	`writerSegmentStats(SegmentsStats stats)`

クラスから継承されたメソッド org.elasticsearch.index.engine.Engine
acquireSearcher, acquireSearcher, close, commitStats, config, ensureOpen, failEngine, flushAndClose, forceMerge, getFromSearcher, getSegmentInfo, guardedRamBytesUsed, isMergedSegment, newSearcher, readLastCommittedSegmentInfos, refreshNeeded, segmentReader, segmentsStats, wrapIfClosed

クラスから継承されたメソッド java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- コンストラクタの詳細
  - InternalEngine
```
public InternalEngine(EngineConfig engineConfig,
                      boolean skipInitialTranslogRecovery)
               throws EngineException
```
    例外:
    
    EngineException
- メソッドの詳細
  - getTranslog
```
public Translog getTranslog()
```
    クラスからコピーされた説明: Engine
    
    returns the translog for this engine
    
    定義:
    
    getTranslog クラス内 Engine
  - recoverFromTranslog
```
protected void recoverFromTranslog(EngineConfig engineConfig,
                                   Translog.TranslogGeneration translogGeneration)
                            throws IOException
```
    例外:
    
    IOException
  - get
```
public Engine.GetResult get(Engine.Get get)
                     throws EngineException
```
    定義:
    
    get クラス内 Engine
    
    例外:
    
    EngineException
  - create
```
public void create(Engine.Create create)
            throws EngineException
```
    定義:
    
    create クラス内 Engine
    
    例外:
    
    EngineException
  - index
```
public boolean index(Engine.Index index)
              throws EngineException
```
    定義:
    
    index クラス内 Engine
    
    例外:
    
    EngineException
  - delete
```
public void delete(Engine.Delete delete)
            throws EngineException
```
    定義:
    
    delete クラス内 Engine
    
    例外:
    
    EngineException
  - delete
```
@Deprecated
public void delete(Engine.DeleteByQuery delete)
                        throws EngineException
```
    非推奨です。 This was removed, but we keep this API so translog can replay any DBQs on upgrade.
    
    定義:
    
    delete クラス内 Engine
    
    例外:
    
    EngineException
  - refresh
```
public void refresh(String source)
             throws EngineException
```
    クラスからコピーされた説明: Engine
    
    Refreshes the engine for new search operations to reflect the latest changes.
    
    定義:
    
    refresh クラス内 Engine
    
    例外:
    
    EngineException
  - syncFlush
```
public Engine.SyncedFlushResult syncFlush(String syncId,
                                          Engine.CommitId expectedCommitId)
                                   throws EngineException
```
    クラスからコピーされた説明: Engine
    
    Attempts to do a special commit where the given syncID is put into the commit data. The attempt succeeds if there are not pending writes in lucene and the current point is equal to the expected one.
    
    定義:
    
    syncFlush クラス内 Engine
    
    パラメータ:
    
    syncId - id of this sync
    
    expectedCommitId - the expected value of
    
    戻り値:
    
    true if the sync commit was made, false o.w.
    
    例外:
    
    EngineException
  - flush
```
public Engine.CommitId flush()
                      throws EngineException
```
    クラスからコピーされた説明: Engine
    
    Flushes the state of the engine including the transaction log, clearing memory and persisting documents in the lucene index to disk including a potentially heavy and durable fsync operation. This operation is not going to block if another flush operation is currently running and won't write a lucene commit if nothing needs to be committed.
    
    定義:
    
    flush クラス内 Engine
    
    戻り値:
    
    the commit Id for the resulting commit
    
    例外:
    
    EngineException
  - flush
```
public Engine.CommitId flush(boolean force,
                             boolean waitIfOngoing)
                      throws EngineException
```
    クラスからコピーされた説明: Engine
    
    Flushes the state of the engine including the transaction log, clearing memory.
    
    定義:
    
    flush クラス内 Engine
    
    パラメータ:
    
    force - if true a lucene commit is executed even if no changes need to be committed.
    
    waitIfOngoing - if true this call will block until all currently running flushes have finished. Otherwise this call will return without blocking.
    
    戻り値:
    
    the commit Id for the resulting commit
    
    例外:
    
    EngineException
  - forceMerge
```
public void forceMerge(boolean flush,
                       int maxNumSegments,
                       boolean onlyExpungeDeletes,
                       boolean upgrade,
                       boolean upgradeOnlyAncientSegments)
                throws EngineException,
                       EngineClosedException,
                       IOException
```
    クラスからコピーされた説明: Engine
    
    Triggers a forced merge on this engine
    
    定義:
    
    forceMerge クラス内 Engine
    
    例外:
    
    EngineException
    
    EngineClosedException
    
    IOException
  - snapshotIndex
```
public SnapshotIndexCommit snapshotIndex(boolean flushFirst)
                                  throws EngineException
```
    クラスからコピーされた説明: Engine
    
    Snapshots the index and returns a handle to it. If needed will try and "commit" the lucene index to make sure we have a "fresh" copy of the files to snapshot.
    
    定義:
    
    snapshotIndex クラス内 Engine
    
    パラメータ:
    
    flushFirst - indicates whether the engine should flush before returning the snapshot
    
    例外:
    
    EngineException
  - maybeFailEngine
```
protected boolean maybeFailEngine(String source,
                                  Throwable t)
```
    クラスからコピーされた説明: Engine
    
    Check whether the engine should be failed
    
    オーバーライド:
    
    maybeFailEngine クラス内 Engine
  - getLastCommittedSegmentInfos
```
protected org.apache.lucene.index.SegmentInfos getLastCommittedSegmentInfos()
```
    定義:
    
    getLastCommittedSegmentInfos クラス内 Engine
  - writerSegmentStats
```
protected final void writerSegmentStats(SegmentsStats stats)
```
    オーバーライド:
    
    writerSegmentStats クラス内 Engine
  - indexWriterRAMBytesUsed
```
public long indexWriterRAMBytesUsed()
```
    クラスからコピーされた説明: Engine
    
    How much heap Lucene's IndexWriter is using
    
    定義:
    
    indexWriterRAMBytesUsed クラス内 Engine
  - segments
```
public List<Segment> segments(boolean verbose)
```
    クラスからコピーされた説明: Engine
    
    The list of segments in the engine.
    
    定義:
    
    segments クラス内 Engine
  - closeNoLock
```
protected final void closeNoLock(String reason)
```
    Closes the engine without acquiring the write lock. This should only be called while the write lock is hold or in a disaster condition ie. if the engine is failed.
    
    定義:
    
    closeNoLock クラス内 Engine
  - hasUncommittedChanges
```
public boolean hasUncommittedChanges()
```
    クラスからコピーされた説明: Engine
    
    Returns true the internal writer has any uncommitted changes. Otherwise false
    
    定義:
    
    hasUncommittedChanges クラス内 Engine
  - getSearcherManager
```
protected org.apache.lucene.search.SearcherManager getSearcherManager()
```
    定義:
    
    getSearcherManager クラス内 Engine
  - activateThrottling
```
public void activateThrottling()
```
  - deactivateThrottling
```
public void deactivateThrottling()
```
  - onSettingsChanged
```
public void onSettingsChanged()
```
    オーバーライド:
    
    onSettingsChanged クラス内 Engine
  - getMergeStats
```
public MergeStats getMergeStats()
```
    オーバーライド:
    
    getMergeStats クラス内 Engine

クラス InternalEngine

ネストされたクラスのサマリー

クラスから継承されたネストされたクラス/インタフェース org.elasticsearch.index.engine.Engine

フィールドのサマリー

クラスから継承されたフィールド org.elasticsearch.index.engine.Engine

コンストラクタのサマリー

メソッドのサマリー

クラスから継承されたメソッド org.elasticsearch.index.engine.Engine

クラスから継承されたメソッド java.lang.Object

コンストラクタの詳細

InternalEngine

メソッドの詳細

getTranslog

recoverFromTranslog

get

create

index

delete

delete

refresh

syncFlush

flush

flush

forceMerge

snapshotIndex

maybeFailEngine

getLastCommittedSegmentInfos

writerSegmentStats

indexWriterRAMBytesUsed

segments

closeNoLock

hasUncommittedChanges

getSearcherManager

activateThrottling

deactivateThrottling

onSettingsChanged

getMergeStats