org.apache.cassandra.db.compaction

## Class CompactionController

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

Direct Known Subclasses:
  SSTableSplitter.SplitController

    public class CompactionController
    extends java.lang.Object

Manage compaction options.

### Field Summary

Fields
`ColumnFamilyStore` `cfs`
`int` `gcBefore`

### Constructor Summary

Constructors
`protected` `CompactionController(ColumnFamilyStore cfs, int maxValue)` Constructor that subclasses may use when overriding shouldPurge to not need overlappingTree
`` `CompactionController(ColumnFamilyStore cfs, java.util.Set<SSTableReader> compacting, int gcBefore)`

### Method Summary

Methods
`void` `close()`
`java.lang.String` `getColumnFamily()`
`AbstractCompactedRow` `getCompactedRow(java.util.List<SSTableIdentityIterator> rows)`
`AbstractCompactedRow` `getCompactedRow(SSTableIdentityIterator row)` convenience method for single-sstable compactions
`java.util.Set<SSTableReader>` `getFullyExpiredSSTables()`
`static java.util.Set<SSTableReader>` `getFullyExpiredSSTables(ColumnFamilyStore cfStore, java.util.Set<SSTableReader> compacting, java.util.Set<SSTableReader> overlapping, int gcBefore)` Finds expired sstables works something like this; 1.
`java.lang.String` `getKeyspace()`
`void` `invalidateCachedRow(DecoratedKey key)`
`boolean` `shouldPurge(DecoratedKey key, long maxDeletionTimestamp)`

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

### Field Detail

#### cfs

    public final ColumnFamilyStore cfs

#### gcBefore

    public final int gcBefore

### Constructor Detail

#### CompactionController

    protected CompactionController(ColumnFamilyStore cfs,
                        int maxValue)

Constructor that subclasses may use when overriding shouldPurge to not need overlappingTree

#### CompactionController

    public CompactionController(ColumnFamilyStore cfs,
                        java.util.Set<SSTableReader> compacting,
                        int gcBefore)

### Method Detail

#### getFullyExpiredSSTables

    public java.util.Set<SSTableReader> getFullyExpiredSSTables()

#### getFullyExpiredSSTables

    public static java.util.Set<SSTableReader> getFullyExpiredSSTables(ColumnFamilyStore cfStore,
                                                       java.util.Set<SSTableReader> compacting,
                                                       java.util.Set<SSTableReader> overlapping,
                                                       int gcBefore)

Finds expired sstables works something like this; 1. find "global" minTimestamp of overlapping sstables (excluding the possibly droppable ones) 2. build a list of candidates to be dropped 3. sort the candidate list, biggest maxTimestamp first in list 4. check if the candidates to be dropped actually can be dropped (maxTimestamp < global minTimestamp) and it is included in the compaction - if not droppable, update global minTimestamp and remove from candidates 5. return candidates.

Parameters:
  `cfStore` -
  `compacting` - we take the drop-candidates from this set, it is usually the sstables included in the compaction
  `overlapping` - the sstables that overlap the ones in compacting.
  `gcBefore` -
Returns:

#### getKeyspace

    public java.lang.String getKeyspace()

#### getColumnFamily

    public java.lang.String getColumnFamily()

#### shouldPurge

    public boolean shouldPurge(DecoratedKey key,
                      long maxDeletionTimestamp)

Returns:
  true if it's okay to drop tombstones for the given row, i.e., if we know all the verisons of the row older than @param maxDeletionTimestamp are included in the compaction set

#### invalidateCachedRow

    public void invalidateCachedRow(DecoratedKey key)

#### getCompactedRow

    public AbstractCompactedRow getCompactedRow(java.util.List<SSTableIdentityIterator> rows)

Returns:
  an AbstractCompactedRow implementation to write the merged rows in question. If there is a single source row, the data is from a current-version sstable, we don't need to purge and we aren't forcing deserialization for scrub, write it unchanged. Otherwise, we deserialize, purge tombstones, and reserialize in the latest version.

#### getCompactedRow

    public AbstractCompactedRow getCompactedRow(SSTableIdentityIterator row)

convenience method for single-sstable compactions

#### close

    public void close()