org.apache.cassandra.db.compaction

Class AbstractCompactionStrategy

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

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

Methods

Modifier and Type	Method and Description
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
AbstractCompactionTask	getCompactionTask(java.util.Collection<SSTableReader> sstables, int gcBefore, long maxSSTableBytes)
abstract int	getEstimatedRemainingTasks()
abstract java.util.Collection<AbstractCompactionTask>	getMaximalTask(int gcBefore)
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.
abstract AbstractCompactionTask	getNextBackgroundTask(int gcBefore)
AbstractCompactionStrategy.ScannerList	getScanners(java.util.Collection<SSTableReader> toCompact)
AbstractCompactionStrategy.ScannerList	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
boolean	shouldBeEnabled()
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

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

uncheckedTombstoneCompaction

protected boolean uncheckedTombstoneCompaction

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 java.util.Collection<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.

getCompactionTask

public AbstractCompactionTask getCompactionTask(java.util.Collection<SSTableReader> sstables,
                                       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

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.

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,
                  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 AbstractCompactionStrategy.ScannerList 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 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()