core/org.gnit.lucenekmp.index/DocumentsWriterPerThread

DocumentsWriterPerThread

class DocumentsWriterPerThread(indexMajorVersionCreated: Int, segmentName: String, directoryOrig: Directory, directory: Directory, indexWriterConfig: LiveIndexWriterConfig, val deleteQueue: DocumentsWriterDeleteQueue, fieldInfos: FieldInfos.Builder, pendingNumDocs: AtomicLong, enableTestPoints: Boolean) : Accountable, Lock

Constructors

DocumentsWriterPerThread

constructor(indexMajorVersionCreated: Int, segmentName: String, directoryOrig: Directory, directory: Directory, indexWriterConfig: LiveIndexWriterConfig, deleteQueue: DocumentsWriterDeleteQueue, fieldInfos: FieldInfos.Builder, pendingNumDocs: AtomicLong, enableTestPoints: Boolean)

Types

object Companion

class FlushedSegment(infoStream: InfoStream, val segmentInfo: SegmentCommitInfo, val fieldInfos: FieldInfos, segmentUpdates: BufferedUpdates?, val liveDocs: FixedBitSet?, val delCount: Int, val sortMap: Sorter.DocMap?)

Properties

open override val childResources: MutableCollection<Accountable>

Returns nested resources of this class. The result should be a point-in-time snapshot (to avoid race conditions).

val codec: Codec

commitLastBytesUsedDelta

val commitLastBytesUsedDelta: Long

val deleteQueue: DocumentsWriterDeleteQueue

val directory: TrackingDirectoryWrapper

var isAborted: Boolean

isHeldByCurrentThread

val isHeldByCurrentThread: Boolean

isQueueAdvanced

val isQueueAdvanced: Boolean

lastCommittedBytesUsed

var lastCommittedBytesUsed: Long

Returns the last committed bytes for this DWPT. This method can be called without acquiring the DWPTs lock.

var numDocsInRAM: Int

Returns the number of RAM resident documents in this DocumentsWriterPerThread

Functions

fun abort()

Called if we hit an exception at a bad time (when updating the index files) and must discard all currently buffered docs. This resets our state, discarding any docs added since last flush.

commitLastBytesUsed

fun commitLastBytesUsed(delta: Long)

Commits the current .ramBytesUsed and stores its value for later reuse. The last committed bytes used can be retrieved via .getLastCommittedBytesUsed

fun flush(flushNotifications: DocumentsWriter.FlushNotifications): DocumentsWriterPerThread.FlushedSegment?

Flush all pending docs to a new segment

fun getSegmentInfo(): SegmentInfo

Get current segment info we are writing.

fun hasFlushed(): Boolean

Returns true iff this DWPT has been flushed

fun isFlushPending(): Boolean

Returns true iff this DWPT is marked as flush pending

open override fun lock()

Acquires the lock.

lockInterruptibly

open override fun lockInterruptibly()

Acquires the lock unless the current thread is interrupted.

open override fun newCondition(): Condition

Returns a new Condition instance that is bound to this Lock instance.

pendingFilesToDelete

fun pendingFilesToDelete(): MutableSet<String>

fun prepareFlush(): FrozenBufferedUpdates?

Prepares this DWPT for flushing. This method will freeze and return the [ ]s global buffer and apply all pending deletes to this DWPT.

open override fun ramBytesUsed(): Long

Return the memory usage of this object in bytes. Negative values are illegal.

sealFlushedSegment

fun sealFlushedSegment(flushedSegment: DocumentsWriterPerThread.FlushedSegment, sortMap: Sorter.DocMap?, flushNotifications: DocumentsWriter.FlushNotifications)

Seals the SegmentInfo for the new flushed segment and persists the deleted documents FixedBitSet.

setFlushPending

fun setFlushPending()

Sets this DWPT as flush pending. This can only be set once.

fun testPoint(message: String)

open override fun toString(): String

open override fun tryLock(): Boolean

Acquires the lock only if it is free at the time of invocation.

open override fun tryLock(time: Long, unit: TimeUnit): Boolean

Acquires the lock if it is free within the given waiting time and the current thread has not been interrupted.

open override fun unlock()

Releases the lock.

updateDocuments

fun updateDocuments(docs: Iterable<out Iterable<out IndexableField>>, deleteNode: DocumentsWriterDeleteQueue.Node<*>?, flushNotifications: DocumentsWriter.FlushNotifications, onNewDocOnRAM: Runnable): Long