All Known Implementing Classes:

SkipListMemtableFactory

Enclosing interface:

Memtable
```
public static interface Memtable.Factory
```
Factory interface for constructing memtables, and querying write durability features. The factory is chosen using the MemtableParams class (passed as argument to CREATE TABLE ... WITH memtable = '<configuration_name>' where the configuration definition is a map given under memtable_configurations in cassandra.yaml). To make that possible, implementations must provide either a static FACTORY field (if they accept no further option) or a static factory(Map<String, String>) method. In the latter case, the method should avoid creating multiple instances of the factory for the same parameters, or factories should at least implement hashCode and equals.

Method Summary

All Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method	Description
`Memtable`	`create(java.util.concurrent.atomic.AtomicReference<CommitLogPosition> commitLogLowerBound, TableMetadataRef metadaRef, Memtable.Owner owner)`	Create a memtable.
`default TableMetrics.ReleasableMetric`	`createMemtableMetrics(TableMetadataRef metadataRef)`	Override this method to include implementation-specific memtable metrics in the table metrics.
`default boolean`	`streamFromMemtable()`	When we need to stream data, we usually flush and stream the resulting sstables.
`default boolean`	`streamToMemtable()`	Normally we can receive streamed sstables directly, skipping the memtable stage (zero-copy-streaming).
`default boolean`	`writesAreDurable()`	This should be true if the memtable can achieve write durability for crash recovery directly (i.e.
`default boolean`	`writesShouldSkipCommitLog()`	If the memtable can achieve write durability directly (i.e.

- Method Detail
  - create
```
Memtable create(java.util.concurrent.atomic.AtomicReference<CommitLogPosition> commitLogLowerBound,
                TableMetadataRef metadaRef,
                Memtable.Owner owner)
```
    Create a memtable.
    
    Parameters:
    
    commitLogLowerBound - A commit log lower bound for the new memtable. This will be equal to the previous memtable's upper bound and defines the span of positions that any flushed sstable will cover.
    
    metadaRef - Pointer to the up-to-date table metadata.
    
    owner - Owning objects that will receive flush requests triggered by the memtable (e.g. on expiration).
  - writesShouldSkipCommitLog
```
default boolean writesShouldSkipCommitLog()
```
    If the memtable can achieve write durability directly (i.e. using some feature other than the commitlog, e.g. persistent memory), it can return true here, in which case the commit log will not store mutations in this table. Note that doing so will prevent point-in-time restores and changed data capture, thus a durable memtable must allow the option of turning commit log writing on even if it does not need it.
  - writesAreDurable
```
default boolean writesAreDurable()
```
    This should be true if the memtable can achieve write durability for crash recovery directly (i.e. using some feature other than the commitlog, e.g. persistent memory). Setting this flag to true means that the commitlog should not replay mutations for this table on restart, and that it should not try to preserve segments that contain relevant data. Unless writesShouldSkipCommitLog() is also true, writes will be recorded in the commit log as they may be needed for changed data capture or point-in-time restore.
  - streamToMemtable
```
default boolean streamToMemtable()
```
    Normally we can receive streamed sstables directly, skipping the memtable stage (zero-copy-streaming). When the memtable is the primary data store (e.g. persistent memtables), it will usually prefer to receive the data instead. If this returns true, all streamed sstables's content will be read and replayed as mutations, disabling zero-copy streaming.
  - streamFromMemtable
```
default boolean streamFromMemtable()
```
    When we need to stream data, we usually flush and stream the resulting sstables. This will not work correctly if the memtable does not want to flush for streaming (e.g. persistent memtables acting as primary data store), because data (not just recent) will be missing from the streamed view. Such memtables must present their data separately for streaming. In other words if the memtable returns false on shouldSwitch(STREAMING/REPAIR), its factory must return true here. If this flag returns true, streaming will write the relevant content that resides in the memtable to temporary sstables, stream these sstables and then delete them.
  - createMemtableMetrics
```
default TableMetrics.ReleasableMetric createMemtableMetrics(TableMetadataRef metadataRef)
```
    Override this method to include implementation-specific memtable metrics in the table metrics. Memtable metrics lifecycle matches table lifecycle. It is the table that owns the metrics and decides when to release them.

Interface Memtable.Factory

Method Summary

Method Detail

create

writesShouldSkipCommitLog

writesAreDurable

streamToMemtable

streamFromMemtable

createMemtableMetrics