AbstractCompactionStrategy (apache-cassandra API)

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

Direct Known Subclasses:

DateTieredCompactionStrategy, LeveledCompactionStrategy, SizeTieredCompactionStrategy, TimeWindowCompactionStrategy
```
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 boolean`	`DEFAULT_LOG_ALL_OPTION`
`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.
`protected static java.lang.String`	`LOG_ALL_OPTION`
`protected boolean`	`logAll`
`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)` Adds sstable, note that implementations must handle duplicate notifications here (added already being in the compaction strategy)
`void`	`addSSTables(java.lang.Iterable<SSTableReader> added)` Adds sstables, note that implementations must handle duplicate notifications here (added already being in the compaction strategy)
`SSTableMultiWriter`	`createSSTableMultiWriter(Descriptor descriptor, long keyCount, long repairedAt, java.util.UUID pendingRepair, boolean isTransient, MetadataCollector meta, SerializationHeader header, java.util.Collection<Index> indexes, LifecycleNewTracker lifecycleNewTracker)`
`static java.util.List<SSTableReader>`	`filterSuspectSSTables(java.lang.Iterable<SSTableReader> originalCandidates)` Filters SSTables that are to be excluded 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()`
`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)`
`protected abstract java.util.Set<SSTableReader>`	`getSSTables()` Returns the sstables managed by this strategy instance
`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.
`void`	`metadataChanged(StatsMetadata oldMetadata, SSTableReader sstable)` Called when the metadata has changed for an sstable - for example if the level changed Not called when repair status changes (which is also metadata), because this results in the sstable getting removed from the compaction strategy instance.
`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)` Removes sstable from the strategy, implementations must be able to handle the sstable having already been removed.
`void`	`removeSSTables(java.lang.Iterable<SSTableReader> removed)` Removes sstables from the strategy, implementations must be able to handle the sstables having already been removed.
`void`	`replaceSSTables(java.util.Collection<SSTableReader> removed, java.util.Collection<SSTableReader> added)` Replaces sstables in the compaction strategy Note that implementations must be able to handle duplicate notifications here (that removed are already gone and added have already been added)
`void`	`resume()` For internal, temporary suspension of background compactions so that we can do exceptional things like truncate or major compaction
`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
`CompactionLogger.Strategy`	`strategyLogger()`
`boolean`	`supportsEarlyOpen()`
`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
  - DEFAULT_LOG_ALL_OPTION
```
protected static final boolean DEFAULT_LOG_ALL_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
  - LOG_ALL_OPTION
```
protected static final java.lang.String LOG_ALL_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
```
  - logAll
```
protected boolean logAll
```
  - 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
  - filterSuspectSSTables
```
public static java.util.List<SSTableReader> filterSuspectSSTables(java.lang.Iterable<SSTableReader> originalCandidates)
```
    Filters SSTables that are to be excluded from the given collection
    
    Parameters:
    
    originalCandidates - The collection to check for excluded SSTables
    
    Returns:
    
    list of the SSTables with excluded 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).
  - getName
```
public java.lang.String getName()
```
  - replaceSSTables
```
public void replaceSSTables(java.util.Collection<SSTableReader> removed,
                            java.util.Collection<SSTableReader> added)
```
    Replaces sstables in the compaction strategy Note that implementations must be able to handle duplicate notifications here (that removed are already gone and added have already been added)
  - addSSTable
```
public abstract void addSSTable(SSTableReader added)
```
    Adds sstable, note that implementations must handle duplicate notifications here (added already being in the compaction strategy)
  - addSSTables
```
public void addSSTables(java.lang.Iterable<SSTableReader> added)
```
    Adds sstables, note that implementations must handle duplicate notifications here (added already being in the compaction strategy)
  - removeSSTable
```
public abstract void removeSSTable(SSTableReader sstable)
```
    Removes sstable from the strategy, implementations must be able to handle the sstable having already been removed.
  - removeSSTables
```
public void removeSSTables(java.lang.Iterable<SSTableReader> removed)
```
    Removes sstables from the strategy, implementations must be able to handle the sstables having already been removed.
  - getSSTables
```
protected abstract java.util.Set<SSTableReader> getSSTables()
```
    Returns the sstables managed by this strategy instance
  - metadataChanged
```
public void metadataChanged(StatsMetadata oldMetadata,
                            SSTableReader sstable)
```
    Called when the metadata has changed for an sstable - for example if the level changed Not called when repair status changes (which is also metadata), because this results in the sstable getting removed from the compaction strategy instance.
    
    Parameters:
    
    oldMetadata -
    
    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
  - 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.
  - strategyLogger
```
public CompactionLogger.Strategy strategyLogger()
```
  - createSSTableMultiWriter
```
public SSTableMultiWriter createSSTableMultiWriter(Descriptor descriptor,
                                                   long keyCount,
                                                   long repairedAt,
                                                   java.util.UUID pendingRepair,
                                                   boolean isTransient,
                                                   MetadataCollector meta,
                                                   SerializationHeader header,
                                                   java.util.Collection<Index> indexes,
                                                   LifecycleNewTracker lifecycleNewTracker)
```
  - supportsEarlyOpen
```
public boolean supportsEarlyOpen()
```

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

DEFAULT_LOG_ALL_OPTION

TOMBSTONE_THRESHOLD_OPTION

TOMBSTONE_COMPACTION_INTERVAL_OPTION

UNCHECKED_TOMBSTONE_COMPACTION_OPTION

LOG_ALL_OPTION

COMPACTION_ENABLED

ONLY_PURGE_REPAIRED_TOMBSTONES

options

cfs

tombstoneThreshold

tombstoneCompactionInterval

uncheckedTombstoneCompaction

disableTombstoneCompactions

logAll

isActive

Constructor Detail

AbstractCompactionStrategy

Method Detail

getDirectories

pause

resume

startup

shutdown

getNextBackgroundTask

getMaximalTask

getUserDefinedTask

getCompactionTask

getEstimatedRemainingTasks

getMaxSSTableBytes

filterSuspectSSTables

getScanners

getScanners

getName

replaceSSTables

addSSTable

addSSTables

removeSSTable

removeSSTables

getSSTables

metadataChanged

getScanners

worthDroppingTombstones

validateOptions

groupSSTablesForAntiCompaction

strategyLogger

createSSTableMultiWriter

supportsEarlyOpen