org.apache.cassandra.db.compaction

## Class SizeTieredCompactionStrategy

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

    public class SizeTieredCompactionStrategy
    extends AbstractCompactionStrategy

### Nested Class Summary

### Nested classes/interfaces inherited from class org.apache.cassandra.db.compaction.AbstractCompactionStrategy

`AbstractCompactionStrategy.ScannerList`

### Field Summary

Fields
`protected int` `estimatedRemainingTasks`
`protected SizeTieredCompactionStrategyOptions` `sizeTieredOptions`

### Fields inherited from class org.apache.cassandra.db.compaction.AbstractCompactionStrategy

`cfs, COMPACTION_ENABLED, DEFAULT_TOMBSTONE_COMPACTION_INTERVAL, DEFAULT_TOMBSTONE_THRESHOLD, DEFAULT_UNCHECKED_TOMBSTONE_COMPACTION_OPTION, disableTombstoneCompactions, enabled, isActive, options, TOMBSTONE_COMPACTION_INTERVAL_OPTION, TOMBSTONE_THRESHOLD_OPTION, tombstoneCompactionInterval, tombstoneThreshold, UNCHECKED_TOMBSTONE_COMPACTION_OPTION, uncheckedTombstoneCompaction`

### Constructor Summary

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

### Method Summary

All Methods Static Methods Instance Methods Concrete Methods
`void` `addSSTable(SSTableReader added)`
`static java.util.List<Pair<SSTableReader,java.lang.Long>>` `createSSTableAndLengthPairs(java.lang.Iterable<SSTableReader> sstables)`
`static <T> java.util.List<java.util.List<T>>` `getBuckets(java.util.Collection<Pair<T,java.lang.Long>> files, double bucketHigh, double bucketLow, long minSSTableSize)`
`int` `getEstimatedRemainingTasks()`
`java.util.Collection<AbstractCompactionTask>` `getMaximalTask(int gcBefore, boolean splitOutput)`
`long` `getMaxSSTableBytes()`
`AbstractCompactionTask` `getNextBackgroundTask(int gcBefore)`
`AbstractCompactionTask` `getUserDefinedTask(java.util.Collection<SSTableReader> sstables, int gcBefore)`
`static java.util.List<SSTableReader>` `mostInterestingBucket(java.util.List<java.util.List<SSTableReader>> buckets, int minThreshold, int maxThreshold)`
`void` `removeSSTable(SSTableReader sstable)`
`boolean` `shouldDefragment()`
`java.lang.String` `toString()`
`static java.util.Map<java.lang.String,java.lang.String>` `validateOptions(java.util.Map<java.lang.String,java.lang.String> options)`

### Methods inherited from class org.apache.cassandra.db.compaction.AbstractCompactionStrategy

`disable, enable, filterSSTablesForReads, filterSuspectSSTables, getCompactionTask, getMemtableReservedSize, getName, getScanners, getScanners, groupSSTablesForAntiCompaction, isAffectedByMeteredFlusher, isEnabled, pause, replaceFlushed, replaceSSTables, resume, shouldBeEnabled, shutdown, startup, worthDroppingTombstones`

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

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

### Field Detail

#### sizeTieredOptions

    protected SizeTieredCompactionStrategyOptions sizeTieredOptions

#### estimatedRemainingTasks

    protected volatile int estimatedRemainingTasks

### Constructor Detail

#### SizeTieredCompactionStrategy

    public SizeTieredCompactionStrategy(ColumnFamilyStore cfs,
                                        java.util.Map<java.lang.String,java.lang.String> options)

### Method Detail

#### mostInterestingBucket

    public static java.util.List<SSTableReader> mostInterestingBucket(java.util.List<java.util.List<SSTableReader>> buckets,
                                                                      int minThreshold,
                                                                      int maxThreshold)

Parameters:
  `buckets` - list of buckets from which to return the most interesting, where "interesting" is the total hotness for reads
  `minThreshold` - minimum number of sstables in a bucket to qualify as interesting
  `maxThreshold` - maximum number of sstables to compact at once (the returned bucket will be trimmed down to this)
Returns:
  a bucket (list) of sstables to compact

#### getNextBackgroundTask

    public AbstractCompactionTask getNextBackgroundTask(int gcBefore)

Specified by:
  `getNextBackgroundTask` in class `AbstractCompactionStrategy`
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 java.util.Collection<AbstractCompactionTask> getMaximalTask(int gcBefore,
                                                                       boolean splitOutput)

Specified by:
  `getMaximalTask` in class `AbstractCompactionStrategy`
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 AbstractCompactionTask getUserDefinedTask(java.util.Collection<SSTableReader> sstables,
                                                     int gcBefore)

Specified by:
  `getUserDefinedTask` in class `AbstractCompactionStrategy`
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 int getEstimatedRemainingTasks()

Specified by:
  `getEstimatedRemainingTasks` in class `AbstractCompactionStrategy`
Returns:
  the number of background tasks estimated to still be needed for this columnfamilystore

#### createSSTableAndLengthPairs

    public static java.util.List<Pair<SSTableReader,java.lang.Long>> createSSTableAndLengthPairs(java.lang.Iterable<SSTableReader> sstables)

#### getBuckets

    public static <T> java.util.List<java.util.List<T>> getBuckets(java.util.Collection<Pair<T,java.lang.Long>> files,
                                                                   double bucketHigh,
                                                                   double bucketLow,
                                                                   long minSSTableSize)

#### getMaxSSTableBytes

    public long getMaxSSTableBytes()

Specified by:
  `getMaxSSTableBytes` in class `AbstractCompactionStrategy`
Returns:
  size in bytes of the largest sstables for this strategy

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

#### shouldDefragment

    public boolean shouldDefragment()

Overrides:
  `shouldDefragment` in class `AbstractCompactionStrategy`

#### addSSTable

    public void addSSTable(SSTableReader added)

Specified by:
  `addSSTable` in class `AbstractCompactionStrategy`

#### removeSSTable

    public void removeSSTable(SSTableReader sstable)

Specified by:
  `removeSSTable` in class `AbstractCompactionStrategy`

#### toString

    public java.lang.String toString()

Overrides:
  `toString` in class `java.lang.Object`