org.apache.cassandra.db.compaction

## Class AbstractCompactionStrategy

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

Direct Known Subclasses:
  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

### Field Summary

Fields
`protected ColumnFamilyStore` `cfs`
`protected static java.lang.String` `COMPACTION_ENABLED`
`protected static long` `DEFAULT_TOMBSTONE_COMPACTION_INTERVAL`
`protected static float` `DEFAULT_TOMBSTONE_THRESHOLD`
`protected boolean` `enabled`
`protected boolean` `isActive` pause/resume/getNextBackgroundTask must synchronize.
`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`

### Constructor Summary

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

### Method Summary

Methods
`void` `disable()`
`void` `enable()`
`java.util.List<SSTableReader>` `filterSSTablesForReads(java.util.List<SSTableReader> sstables)`
`static java.lang.Iterable<SSTableReader>` `filterSuspectSSTables(java.lang.Iterable<SSTableReader> originalCandidates)` Filters SSTables that are to be blacklisted from the given collection
`abstract int` `getEstimatedRemainingTasks()`
`abstract AbstractCompactionTask` `getMaximalTask(int gcBefore)`
`abstract long` `getMaxSSTableBytes()`
`abstract AbstractCompactionTask` `getNextBackgroundTask(int gcBefore)`
`java.util.List<ICompactionScanner>` `getScanners(java.util.Collection<SSTableReader> toCompact)`
`java.util.List<ICompactionScanner>` `getScanners(java.util.Collection<SSTableReader> sstables, Range<Token> range)` Returns a list of KeyScanners given sstables and a range on which to scan.
`abstract AbstractCompactionTask` `getUserDefinedTask(java.util.Collection<SSTableReader> sstables, int gcBefore)`
`boolean` `isAffectedByMeteredFlusher()`
`boolean` `isEnabled()`
`void` `pause()` For internal, temporary suspension of background compactions so that we can do exceptional things like truncate or major compaction
`void` `replaceFlushed(Memtable memtable, SSTableReader sstable)` Handle a flushed memtable.
`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
`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

#### 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

#### COMPACTION_ENABLED

    protected static final java.lang.String COMPACTION_ENABLED

See Also:
  Constant Field Values

#### options

    public final java.util.Map<java.lang.String,java.lang.String> options

#### cfs

    protected final ColumnFamilyStore cfs

#### tombstoneThreshold

    protected float tombstoneThreshold

#### tombstoneCompactionInterval

    protected long tombstoneCompactionInterval

#### 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

#### enabled

    protected volatile boolean enabled

### Constructor Detail

#### AbstractCompactionStrategy

    protected AbstractCompactionStrategy(ColumnFamilyStore cfs,
                              java.util.Map<java.lang.String,java.lang.String> options)

### Method Detail

#### 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 AbstractCompactionTask getMaximalTask(int gcBefore)

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.

#### 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

#### isEnabled

    public boolean isEnabled()

#### 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.

#### replaceFlushed

    public void replaceFlushed(Memtable memtable,
                      SSTableReader sstable)

Handle a flushed memtable.

Parameters:
  `memtable` - the flushed memtable
  `sstable` - the written sstable. can be null if the memtable was clean.

#### filterSSTablesForReads

    public java.util.List<SSTableReader> filterSSTablesForReads(java.util.List<SSTableReader> sstables)

Returns:
  a subset of the suggested sstables that are relevant for read requests.

#### 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 java.util.List<ICompactionScanner> getScanners(java.util.Collection<SSTableReader> sstables,
                                                 Range<Token> range)

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).

#### getScanners

    public java.util.List<ICompactionScanner> 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`