AbstractCompactionStrategy (apache-cassandra API)

java.lang.Object
- org.apache.cassandra.db.compaction.AbstractCompactionStrategy

Direct Known Subclasses:

DateTieredCompactionStrategy, LeveledCompactionStrategy, SizeTieredCompactionStrategy
```
public abstract class AbstractCompactionStrategy
extends java.lang.Object
```
Pluggable compaction strategy determines how SSTables get merged. There are two main goals: - perform background compaction constantly as needed; this typically makes a tradeoff between i/o done by compaction, and merging done at read time. - perform a full (maximum possible) compaction if requested by the user

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class AbstractCompactionStrategy.ScannerList

Nested Classes
Modifier and Type	Class and Description
`static class`	`AbstractCompactionStrategy.ScannerList`

Field Summary

Fields
Modifier and Type	Field and Description
`protected ColumnFamilyStore`	`cfs`
`protected static java.lang.String`	`COMPACTION_ENABLED`
`protected static long`	`DEFAULT_TOMBSTONE_COMPACTION_INTERVAL`
`protected static float`	`DEFAULT_TOMBSTONE_THRESHOLD`
`protected static boolean`	`DEFAULT_UNCHECKED_TOMBSTONE_COMPACTION_OPTION`
`protected boolean`	`disableTombstoneCompactions`
`protected boolean`	`isActive` pause/resume/getNextBackgroundTask must synchronize.
`static java.lang.String`	`ONLY_PURGE_REPAIRED_TOMBSTONES`
`protected java.util.Map<java.lang.String,java.lang.String>`	`options`
`protected static java.lang.String`	`TOMBSTONE_COMPACTION_INTERVAL_OPTION`
`protected static java.lang.String`	`TOMBSTONE_THRESHOLD_OPTION`
`protected long`	`tombstoneCompactionInterval`
`protected float`	`tombstoneThreshold`
`protected static java.lang.String`	`UNCHECKED_TOMBSTONE_COMPACTION_OPTION`
`protected boolean`	`uncheckedTombstoneCompaction`

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`AbstractCompactionStrategy(ColumnFamilyStore cfs, java.util.Map<java.lang.String,java.lang.String> options)`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`abstract void`	`addSSTable(SSTableReader added)`
`SSTableMultiWriter`	`createSSTableMultiWriter(Descriptor descriptor, long keyCount, long repairedAt, MetadataCollector meta, SerializationHeader header, LifecycleTransaction txn)`
`void`	`disable()`
`void`	`enable()`
`static java.lang.Iterable<SSTableReader>`	`filterSuspectSSTables(java.lang.Iterable<SSTableReader> originalCandidates)` Filters SSTables that are to be blacklisted from the given collection
`AbstractCompactionTask`	`getCompactionTask(LifecycleTransaction txn, int gcBefore, long maxSSTableBytes)`
`Directories`	`getDirectories()`
`abstract int`	`getEstimatedRemainingTasks()`
`abstract java.util.Collection<AbstractCompactionTask>`	`getMaximalTask(int gcBefore, boolean splitOutput)`
`abstract long`	`getMaxSSTableBytes()`
`long`	`getMemtableReservedSize()` If not affected by MeteredFlusher (and handling flushing on its own), override to tell MF how much space to reserve for this CF, i.e., how much space to subtract from `memtable_total_space_in_mb` when deciding if other memtables should be flushed or not.
`java.lang.String`	`getName()`
`abstract AbstractCompactionTask`	`getNextBackgroundTask(int gcBefore)`
`AbstractCompactionStrategy.ScannerList`	`getScanners(java.util.Collection<SSTableReader> toCompact)`
`AbstractCompactionStrategy.ScannerList`	`getScanners(java.util.Collection<SSTableReader> sstables, java.util.Collection<Range<Token>> ranges)` Returns a list of KeyScanners given sstables and a range on which to scan.
`AbstractCompactionStrategy.ScannerList`	`getScanners(java.util.Collection<SSTableReader> sstables, Range<Token> range)`
`abstract AbstractCompactionTask`	`getUserDefinedTask(java.util.Collection<SSTableReader> sstables, int gcBefore)`
`java.util.Collection<java.util.Collection<SSTableReader>>`	`groupSSTablesForAntiCompaction(java.util.Collection<SSTableReader> sstablesToGroup)` Method for grouping similar SSTables together, This will be used by anti-compaction to determine which SSTables should be anitcompacted as a group.
`boolean`	`isAffectedByMeteredFlusher()`
`void`	`pause()` For internal, temporary suspension of background compactions so that we can do exceptional things like truncate or major compaction
`abstract void`	`removeSSTable(SSTableReader sstable)`
`void`	`replaceFlushed(Memtable memtable, java.util.Collection<SSTableReader> sstables)` Handle a flushed memtable.
`void`	`replaceSSTables(java.util.Collection<SSTableReader> removed, java.util.Collection<SSTableReader> added)`
`void`	`resume()` For internal, temporary suspension of background compactions so that we can do exceptional things like truncate or major compaction
`boolean`	`shouldBeEnabled()`
`boolean`	`shouldDefragment()`
`void`	`shutdown()` Releases any resources if this strategy is shutdown (when the CFS is reloaded after a schema change).
`void`	`startup()` Performs any extra initialization required
`static java.util.Map<java.lang.String,java.lang.String>`	`validateOptions(java.util.Map<java.lang.String,java.lang.String> options)`
`protected boolean`	`worthDroppingTombstones(SSTableReader sstable, int gcBefore)` Check if given sstable is worth dropping tombstones at gcBefore.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - DEFAULT_TOMBSTONE_THRESHOLD
```
protected static final float DEFAULT_TOMBSTONE_THRESHOLD
```
    See Also:
    
    Constant Field Values
  - DEFAULT_TOMBSTONE_COMPACTION_INTERVAL
```
protected static final long DEFAULT_TOMBSTONE_COMPACTION_INTERVAL
```
    See Also:
    
    Constant Field Values
  - DEFAULT_UNCHECKED_TOMBSTONE_COMPACTION_OPTION
```
protected static final boolean DEFAULT_UNCHECKED_TOMBSTONE_COMPACTION_OPTION
```
    See Also:
    
    Constant Field Values
  - TOMBSTONE_THRESHOLD_OPTION
```
protected static final java.lang.String TOMBSTONE_THRESHOLD_OPTION
```
    See Also:
    
    Constant Field Values
  - TOMBSTONE_COMPACTION_INTERVAL_OPTION
```
protected static final java.lang.String TOMBSTONE_COMPACTION_INTERVAL_OPTION
```
    See Also:
    
    Constant Field Values
  - UNCHECKED_TOMBSTONE_COMPACTION_OPTION
```
protected static final java.lang.String UNCHECKED_TOMBSTONE_COMPACTION_OPTION
```
    See Also:
    
    Constant Field Values
  - COMPACTION_ENABLED
```
protected static final java.lang.String COMPACTION_ENABLED
```
    See Also:
    
    Constant Field Values
  - ONLY_PURGE_REPAIRED_TOMBSTONES
```
public static final java.lang.String ONLY_PURGE_REPAIRED_TOMBSTONES
```
    See Also:
    
    Constant Field Values
  - options
```
protected java.util.Map<java.lang.String,java.lang.String> options
```
  - cfs
```
protected final ColumnFamilyStore cfs
```
  - tombstoneThreshold
```
protected float tombstoneThreshold
```
  - tombstoneCompactionInterval
```
protected long tombstoneCompactionInterval
```
  - uncheckedTombstoneCompaction
```
protected boolean uncheckedTombstoneCompaction
```
  - disableTombstoneCompactions
```
protected boolean disableTombstoneCompactions
```
  - isActive
```
protected boolean isActive
```
    pause/resume/getNextBackgroundTask must synchronize. This guarantees that after pause completes, no new tasks will be generated; or put another way, pause can't run until in-progress tasks are done being created. This allows runWithCompactionsDisabled to be confident that after pausing, once in-progress tasks abort, it's safe to proceed with truncate/cleanup/etc. See CASSANDRA-3430
- Constructor Detail
  - AbstractCompactionStrategy
```
protected AbstractCompactionStrategy(ColumnFamilyStore cfs,
                                     java.util.Map<java.lang.String,java.lang.String> options)
```
- Method Detail
  - getDirectories
```
public Directories getDirectories()
```
  - pause
```
public void pause()
```
    For internal, temporary suspension of background compactions so that we can do exceptional things like truncate or major compaction
  - resume
```
public void resume()
```
    For internal, temporary suspension of background compactions so that we can do exceptional things like truncate or major compaction
  - startup
```
public void startup()
```
    Performs any extra initialization required
  - shutdown
```
public void shutdown()
```
    Releases any resources if this strategy is shutdown (when the CFS is reloaded after a schema change).
  - getNextBackgroundTask
```
public abstract AbstractCompactionTask getNextBackgroundTask(int gcBefore)
```
    Parameters:
    
    gcBefore - throw away tombstones older than this
    
    Returns:
    
    the next background/minor compaction task to run; null if nothing to do. Is responsible for marking its sstables as compaction-pending.
  - getMaximalTask
```
public abstract java.util.Collection<AbstractCompactionTask> getMaximalTask(int gcBefore,
                                                                            boolean splitOutput)
```
    Parameters:
    
    gcBefore - throw away tombstones older than this
    
    Returns:
    
    a compaction task that should be run to compact this columnfamilystore as much as possible. Null if nothing to do. Is responsible for marking its sstables as compaction-pending.
  - getUserDefinedTask
```
public abstract AbstractCompactionTask getUserDefinedTask(java.util.Collection<SSTableReader> sstables,
                                                          int gcBefore)
```
    Parameters:
    
    sstables - SSTables to compact. Must be marked as compacting.
    
    gcBefore - throw away tombstones older than this
    
    Returns:
    
    a compaction task corresponding to the requested sstables. Will not be null. (Will throw if user requests an invalid compaction.) Is responsible for marking its sstables as compaction-pending.
  - getCompactionTask
```
public AbstractCompactionTask getCompactionTask(LifecycleTransaction txn,
                                                int gcBefore,
                                                long maxSSTableBytes)
```
  - getEstimatedRemainingTasks
```
public abstract int getEstimatedRemainingTasks()
```
    Returns:
    
    the number of background tasks estimated to still be needed for this columnfamilystore
  - getMaxSSTableBytes
```
public abstract long getMaxSSTableBytes()
```
    Returns:
    
    size in bytes of the largest sstables for this strategy
  - enable
```
public void enable()
```
  - disable
```
public void disable()
```
  - isAffectedByMeteredFlusher
```
public boolean isAffectedByMeteredFlusher()
```
    Returns:
    
    whether or not MeteredFlusher should be able to trigger memtable flushes for this CF.
  - getMemtableReservedSize
```
public long getMemtableReservedSize()
```
    If not affected by MeteredFlusher (and handling flushing on its own), override to tell MF how much space to reserve for this CF, i.e., how much space to subtract from `memtable_total_space_in_mb` when deciding if other memtables should be flushed or not.
  - replaceFlushed
```
public void replaceFlushed(Memtable memtable,
                           java.util.Collection<SSTableReader> sstables)
```
    Handle a flushed memtable.
    
    Parameters:
    
    memtable - the flushed memtable
    
    sstables - the written sstables. can be null or empty if the memtable was clean.
  - filterSuspectSSTables
```
public static java.lang.Iterable<SSTableReader> filterSuspectSSTables(java.lang.Iterable<SSTableReader> originalCandidates)
```
    Filters SSTables that are to be blacklisted from the given collection
    
    Parameters:
    
    originalCandidates - The collection to check for blacklisted SSTables
    
    Returns:
    
    list of the SSTables with blacklisted ones filtered out
  - getScanners
```
public AbstractCompactionStrategy.ScannerList getScanners(java.util.Collection<SSTableReader> sstables,
                                                          Range<Token> range)
```
  - getScanners
```
public AbstractCompactionStrategy.ScannerList getScanners(java.util.Collection<SSTableReader> sstables,
                                                          java.util.Collection<Range<Token>> ranges)
```
    Returns a list of KeyScanners given sstables and a range on which to scan. The default implementation simply grab one SSTableScanner per-sstable, but overriding this method allow for a more memory efficient solution if we know the sstable don't overlap (see LeveledCompactionStrategy for instance).
  - shouldDefragment
```
public boolean shouldDefragment()
```
  - getName
```
public java.lang.String getName()
```
  - replaceSSTables
```
public void replaceSSTables(java.util.Collection<SSTableReader> removed,
                            java.util.Collection<SSTableReader> added)
```
  - addSSTable
```
public abstract void addSSTable(SSTableReader added)
```
  - removeSSTable
```
public abstract void removeSSTable(SSTableReader sstable)
```
  - getScanners
```
public AbstractCompactionStrategy.ScannerList getScanners(java.util.Collection<SSTableReader> toCompact)
```
  - worthDroppingTombstones
```
protected boolean worthDroppingTombstones(SSTableReader sstable,
                                          int gcBefore)
```
    Check if given sstable is worth dropping tombstones at gcBefore. Check is skipped if tombstone_compaction_interval time does not elapse since sstable creation and returns false.
    
    Parameters:
    
    sstable - SSTable to check
    
    gcBefore - time to drop tombstones
    
    Returns:
    
    true if given sstable's tombstones are expected to be removed
  - validateOptions
```
public static java.util.Map<java.lang.String,java.lang.String> validateOptions(java.util.Map<java.lang.String,java.lang.String> options)
                                                                        throws ConfigurationException
```
    Throws:
    
    ConfigurationException
  - shouldBeEnabled
```
public boolean shouldBeEnabled()
```
  - groupSSTablesForAntiCompaction
```
public java.util.Collection<java.util.Collection<SSTableReader>> groupSSTablesForAntiCompaction(java.util.Collection<SSTableReader> sstablesToGroup)
```
    Method for grouping similar SSTables together, This will be used by anti-compaction to determine which SSTables should be anitcompacted as a group. If a given compaction strategy creates sstables which cannot be merged due to some constraint it must override this method.
  - createSSTableMultiWriter
```
public SSTableMultiWriter createSSTableMultiWriter(Descriptor descriptor,
                                                   long keyCount,
                                                   long repairedAt,
                                                   MetadataCollector meta,
                                                   SerializationHeader header,
                                                   LifecycleTransaction txn)
```

Class AbstractCompactionStrategy

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

DEFAULT_TOMBSTONE_THRESHOLD

DEFAULT_TOMBSTONE_COMPACTION_INTERVAL

DEFAULT_UNCHECKED_TOMBSTONE_COMPACTION_OPTION

TOMBSTONE_THRESHOLD_OPTION

TOMBSTONE_COMPACTION_INTERVAL_OPTION

UNCHECKED_TOMBSTONE_COMPACTION_OPTION

COMPACTION_ENABLED

ONLY_PURGE_REPAIRED_TOMBSTONES

options

cfs

tombstoneThreshold

tombstoneCompactionInterval

uncheckedTombstoneCompaction

disableTombstoneCompactions

isActive

Constructor Detail

AbstractCompactionStrategy

Method Detail

getDirectories

pause

resume

startup

shutdown

getNextBackgroundTask

getMaximalTask

getUserDefinedTask

getCompactionTask

getEstimatedRemainingTasks

getMaxSSTableBytes

enable

disable

isAffectedByMeteredFlusher

getMemtableReservedSize

replaceFlushed

filterSuspectSSTables

getScanners

getScanners

shouldDefragment

getName

replaceSSTables

addSSTable

removeSSTable

getScanners

worthDroppingTombstones

validateOptions

shouldBeEnabled

groupSSTablesForAntiCompaction

createSSTableMultiWriter