ColumnFamilyStore (apache-cassandra API)

java.lang.Object
- org.apache.cassandra.db.ColumnFamilyStore

All Implemented Interfaces:: ColumnFamilyStoreMBean

public class ColumnFamilyStore
extends java.lang.Object
implements ColumnFamilyStoreMBean

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class ColumnFamilyStore.AbstractScanIterator

static class ColumnFamilyStore.ViewFragment

Nested Classes
Modifier and Type	Class and Description
`static class`	`ColumnFamilyStore.AbstractScanIterator`
`static class`	`ColumnFamilyStore.ViewFragment`

Field Summary

Fields
Modifier and Type	Field and Description
`Directories`	`directories`
`SecondaryIndexManager`	`indexManager`
`java.util.concurrent.ConcurrentMap<java.nio.ByteBuffer,java.nio.ByteBuffer>`	`internedNames`
`Keyspace`	`keyspace`
`CFMetaData`	`metadata`
`ColumnFamilyMetrics`	`metric`
`java.lang.String`	`name`
`IPartitioner`	`partitioner`
`static java.util.concurrent.ExecutorService`	`postFlushExecutor`
`long`	`sampleLatencyNanos`

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`addSSTable(SSTableReader sstable)`
`void`	`addSSTables(java.util.Collection<SSTableReader> sstables)`
`static java.lang.Iterable<ColumnFamilyStore>`	`all()`
`void`	`apply(DecoratedKey key, ColumnFamily columnFamily, SecondaryIndexManager.Updater indexer)` Insert/Update the column family for this key.
`void`	`cleanupCache()`
`void`	`clearSnapshot(java.lang.String snapshotName)` Clear all the snapshots for a given column family.
`void`	`clearUnsafe()` For testing.
`java.lang.Iterable<ColumnFamilyStore>`	`concatWithIndexes()`
`boolean`	`containsCachedRow(DecoratedKey key)`
`static ColumnFamilyStore`	`createColumnFamilyStore(Keyspace keyspace, java.lang.String columnFamily, boolean loadSSTables)`
`static ColumnFamilyStore`	`createColumnFamilyStore(Keyspace keyspace, java.lang.String columnFamily, IPartitioner partitioner, CFMetaData metadata)`
`void`	`disableAutoCompaction()`
`ReplayPosition`	`discardSSTables(long truncatedAt)` Discard all SSTables that were created before given timestamp.
`void`	`enableAutoCompaction()`
`void`	`enableAutoCompaction(boolean waitForFutures)` used for tests - to be able to check things after a minor compaction
`long`	`estimateKeys()`
`java.util.List<Row>`	`filter(ColumnFamilyStore.AbstractScanIterator rowIterator, ExtendedFilter filter)`
`void`	`forceBlockingFlush()`
`void`	`forceCleanup(CounterId.OneShotRenewer renewer)`
`java.util.concurrent.Future<?>`	`forceFlush()`
`void`	`forceMajorCompaction()` force a major compaction of this column family
`int`	`gcBefore(long now)`
`long`	`getAllMemtablesLiveSize()`
`java.util.Set<SSTableReader>`	`getAndReferenceOverlappingSSTables(java.util.Collection<SSTableReader> sstables)` like getOverlappingSSTables, but acquires references before returning
`long`	`getBloomFilterDiskSpaceUsed()`
`long`	`getBloomFilterFalsePositives()`
`double`	`getBloomFilterFalseRatio()`
`long`	`getBloomFilterOffHeapMemoryUsed()`
`java.util.List<java.lang.String>`	`getBuiltIndexes()` Returns a list of the names of the built column indexes for current store
`ColumnFamily`	`getColumnFamily(DecoratedKey key, java.nio.ByteBuffer start, java.nio.ByteBuffer finish, boolean reversed, int limit, long timestamp)`
`ColumnFamily`	`getColumnFamily(QueryFilter filter)` get a list of columns starting from a given column, in a specified order.
`java.lang.String`	`getColumnFamilyName()`
`AbstractCompactionStrategy`	`getCompactionStrategy()`
`java.lang.String`	`getCompactionStrategyClass()` Gets the compaction strategy class name
`AbstractType<?>`	`getComparator()`
`long`	`getCompressionMetadataOffHeapMemoryUsed()`
`java.util.Map<java.lang.String,java.lang.String>`	`getCompressionParameters()` Get the compression parameters
`double`	`getCompressionRatio()`
`DataTracker`	`getDataTracker()` Package protected for access from the CompactionManager.
`double`	`getDroppableTombstoneRatio()` Get the ratio of droppable tombstones to real columns (and non-droppable tombstones)
`long[]`	`getEstimatedColumnCountHistogram()`
`long[]`	`getEstimatedRowSizeHistogram()`
`long`	`getExpectedCompactedFileSize(java.lang.Iterable<SSTableReader> sstables, OperationType operation)` Calculate expected file size of SSTable after compaction.
`long`	`getIndexSummaryOffHeapMemoryUsed()`
`long[]`	`getLifetimeReadLatencyHistogramMicros()`
`long[]`	`getLifetimeWriteLatencyHistogramMicros()`
`double`	`getLiveCellsPerSlice()` Number of live cells retreived during the last slicequery
`long`	`getLiveDiskSpaceUsed()`
`int`	`getLiveSSTableCount()`
`int`	`getMaximumCompactionThreshold()` Gets the maximum number of sstables in queue before compaction kicks off
`long`	`getMaxRowSize()`
`SSTableReader`	`getMaxSizeFile(java.lang.Iterable<SSTableReader> sstables)`
`int`	`getMeanColumns()`
`long`	`getMeanRowSize()`
`long`	`getMemtableColumnsCount()` Returns the total number of columns present in the memtable.
`long`	`getMemtableDataSize()` Returns the total amount of data stored in the memtable, including column related overhead.
`java.util.Set<Memtable>`	`getMemtablesPendingFlush()`
`int`	`getMemtableSwitchCount()` Returns the number of times that a flush has resulted in the memtable being switched out.
`int`	`getMinimumCompactionThreshold()` Gets the minimum number of sstables in queue before compaction kicks off
`long`	`getMinRowSize()`
`java.util.Set<SSTableReader>`	`getOverlappingSSTables(java.util.Collection<SSTableReader> sstables)`
`int`	`getPendingTasks()`
`java.util.List<Row>`	`getRangeSlice(AbstractBounds<RowPosition> range, java.util.List<org.apache.cassandra.thrift.IndexExpression> rowFilter, IDiskAtomFilter columnFilter, int maxResults)`
`java.util.List<Row>`	`getRangeSlice(AbstractBounds<RowPosition> range, java.util.List<org.apache.cassandra.thrift.IndexExpression> rowFilter, IDiskAtomFilter columnFilter, int maxResults, long now)`
`java.util.List<Row>`	`getRangeSlice(AbstractBounds<RowPosition> range, java.util.List<org.apache.cassandra.thrift.IndexExpression> rowFilter, IDiskAtomFilter columnFilter, int maxResults, long now, boolean countCQL3Rows, boolean isPaging)`
`java.util.List<Row>`	`getRangeSlice(ExtendedFilter filter)`
`ColumnFamily`	`getRawCachedRow(DecoratedKey key)`
`long`	`getReadCount()`
`long`	`getRecentBloomFilterFalsePositives()`
`double`	`getRecentBloomFilterFalseRatio()`
`long[]`	`getRecentReadLatencyHistogramMicros()`
`double`	`getRecentReadLatencyMicros()`
`long[]`	`getRecentSSTablesPerReadHistogram()`
`long[]`	`getRecentWriteLatencyHistogramMicros()`
`double`	`getRecentWriteLatencyMicros()`
`long`	`getSnapshotCreationTime(java.lang.String snapshotName)`
`java.util.List<SSTableReader>`	`getSnapshotSSTableReader(java.lang.String tag)`
`int[]`	`getSSTableCountPerLevel()`
`java.util.Collection<SSTableReader>`	`getSSTables()`
`java.util.List<java.lang.String>`	`getSSTablesForKey(java.lang.String key)` Returns a list of filenames that contain the given key on this node
`long[]`	`getSSTablesPerReadHistogram()`
`java.lang.String`	`getTempSSTablePath(java.io.File directory)`
`double`	`getTombstonesPerSlice()` Number of tombstoned cells retreived during the last slicequery
`ColumnFamily`	`getTopLevelColumns(QueryFilter filter, int gcBefore)`
`long`	`getTotalAllMemtablesLiveSize()`
`long`	`getTotalDiskSpaceUsed()`
`long`	`getTotalMemtableLiveSize()`
`long`	`getTotalReadLatencyMicros()`
`long`	`getTotalWriteLatencyMicros()`
`java.util.Set<SSTableReader>`	`getUncompactingSSTables()`
`int`	`getUnleveledSSTables()`
`long`	`getWriteCount()`
`void`	`initRowCache()`
`java.nio.ByteBuffer`	`internOrCopy(java.nio.ByteBuffer name, Allocator allocator)`
`void`	`invalidate()` call when dropping or renaming a CF.
`void`	`invalidateCachedRow(DecoratedKey key)`
`void`	`invalidateCachedRow(RowCacheKey key)`
`boolean`	`isAutoCompactionDisabled()`
`boolean`	`isEmpty()`
`boolean`	`isIndex()` true if this CFS contains secondary index data
`boolean`	`isValid()`
`java.lang.Iterable<DecoratedKey>`	`keySamples(Range<Token> range)`
`void`	`loadNewSSTables()` #Scan through Keyspace/ColumnFamily's data directory determine which SSTables should be loaded and load them
`static void`	`loadNewSSTables(java.lang.String ksName, java.lang.String cfName)` See #`StorageService.loadNewSSTables(String, String)` for more info
`ExtendedFilter`	`makeExtendedFilter(AbstractBounds<RowPosition> range, IDiskAtomFilter columnFilter, java.util.List<org.apache.cassandra.thrift.IndexExpression> rowFilter, int maxResults, boolean countCQL3Rows, boolean isPaging, long timestamp)`
`ExtendedFilter`	`makeExtendedFilter(AbstractBounds<RowPosition> keyRange, SliceQueryFilter columnRange, java.nio.ByteBuffer columnStart, java.nio.ByteBuffer columnStop, java.util.List<org.apache.cassandra.thrift.IndexExpression> rowFilter, int maxResults, boolean countCQL3Rows, long now)` Allows generic range paging with the slice column filter.
`java.lang.Iterable<SSTableReader>`	`markAllCompacting()`
`java.util.Collection<SSTableReader>`	`markCurrentSSTablesReferenced()` Get the current sstables, acquiring references on all of them.
`void`	`markObsolete(java.util.Collection<SSTableReader> sstables, OperationType compactionType)`
`ColumnFamilyStore.ViewFragment`	`markReferenced(AbstractBounds<RowPosition> rowBounds)`
`ColumnFamilyStore.ViewFragment`	`markReferenced(java.util.Collection<AbstractBounds<RowPosition>> rowBoundsCollection)`
`ColumnFamilyStore.ViewFragment`	`markReferenced(DecoratedKey key)`
`java.nio.ByteBuffer`	`maybeIntern(java.nio.ByteBuffer name)`
`void`	`maybeUpdateRowCache(DecoratedKey key)`
`long`	`oldestUnflushedMemtable()` Returns the creation time of the oldest memtable not fully flushed yet.
`static void`	`rebuildSecondaryIndex(java.lang.String ksName, java.lang.String cfName, java.lang.String... idxNames)`
`void`	`reload()`
`static ColumnFamily`	`removeDeleted(ColumnFamily cf, int gcBefore)` Removes deleted columns and purges gc-able tombstones.
`static ColumnFamily`	`removeDeleted(ColumnFamily cf, int gcBefore, SecondaryIndexManager.Updater indexer)`
`static ColumnFamily`	`removeDeletedCF(ColumnFamily cf, int gcBefore)` Purges gc-able top-level and range tombstones, returning `cf` if there are any columns or tombstones left, null otherwise.
`static long`	`removeDeletedColumnsOnly(ColumnFamily cf, int gcBefore)`
`static long`	`removeDeletedColumnsOnly(ColumnFamily cf, int gcBefore, SecondaryIndexManager.Updater indexer)` Removes only per-cell tombstones, cells that are shadowed by a row-level or range tombstone, or columns that have been dropped from the schema (for CQL3 tables only).
`static void`	`removeUnfinishedCompactionLeftovers(java.lang.String keyspace, java.lang.String columnfamily, java.util.Map<java.lang.Integer,java.util.UUID> unfinishedCompactions)` Replacing compacted sstables is atomic as far as observers of DataTracker are concerned, but not on the filesystem: first the new sstables are renamed to "live" status (i.e., the tmp marker is removed), then their ancestors are removed.
`void`	`replaceCompactedSSTables(java.util.Collection<SSTableReader> sstables, java.util.Collection<SSTableReader> replacements, OperationType compactionType)`
`<V> V`	`runWithCompactionsDisabled(java.util.concurrent.Callable<V> callable, boolean interruptValidation)`
`void`	`scrub(boolean disableSnapshot, boolean skipCorrupted)`
`static void`	`scrubDataDirectories(java.lang.String keyspaceName, java.lang.String columnFamily)` Removes unnecessary files from the cf directory at startup: these include temp files, orphans, zero-length files and compacted sstables.
`java.util.List<Row>`	`search(AbstractBounds<RowPosition> range, java.util.List<org.apache.cassandra.thrift.IndexExpression> clause, IDiskAtomFilter dataFilter, int maxResults)`
`java.util.List<Row>`	`search(AbstractBounds<RowPosition> range, java.util.List<org.apache.cassandra.thrift.IndexExpression> clause, IDiskAtomFilter dataFilter, int maxResults, long now)`
`java.util.List<Row>`	`search(ExtendedFilter filter)`
`void`	`setCompactionStrategyClass(java.lang.String compactionStrategyClass)` Sets the compaction strategy by class name
`void`	`setCompactionThresholds(int minThreshold, int maxThreshold)` Sets the maximum and maximum number of SSTables in queue before compaction kicks off
`void`	`setCompressionParameters(java.util.Map<java.lang.String,java.lang.String> opts)` Set the compression parameters
`void`	`setCrcCheckChance(double crcCheckChance)` Set new crc check chance
`void`	`setMaximumCompactionThreshold(int maxCompactionThreshold)` Sets the maximum number of sstables in queue before compaction kicks off
`void`	`setMinimumCompactionThreshold(int minCompactionThreshold)` Sets the minimum number of sstables in queue before compaction kicks off
`void`	`snapshot(java.lang.String snapshotName)` Take a snap shot of this columnfamily store.
`boolean`	`snapshotExists(java.lang.String snapshotName)`
`void`	`snapshotWithoutFlush(java.lang.String snapshotName)`
`void`	`sstablesRewrite(boolean excludeCurrentVersion)`
`java.util.concurrent.Future<?>`	`switchMemtable(boolean writeCommitLog, boolean forceSwitch)` Switch and flush the current memtable, if it was dirty.
`java.lang.String`	`toString()`
`void`	`truncateBlocking()` Truncate deletes the entire column family's data with no expensive tombstone creation

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - postFlushExecutor
```
public static final java.util.concurrent.ExecutorService postFlushExecutor
```
  - keyspace
```
public final Keyspace keyspace
```
  - name
```
public final java.lang.String name
```
  - metadata
```
public final CFMetaData metadata
```
  - partitioner
```
public final IPartitioner partitioner
```
  - indexManager
```
public final SecondaryIndexManager indexManager
```
  - internedNames
```
public final java.util.concurrent.ConcurrentMap<java.nio.ByteBuffer,java.nio.ByteBuffer> internedNames
```
  - directories
```
public final Directories directories
```
  - metric
```
public final ColumnFamilyMetrics metric
```
  - sampleLatencyNanos
```
public volatile long sampleLatencyNanos
```
- Method Detail
  - reload
```
public void reload()
```
  - setCompactionStrategyClass
```
public void setCompactionStrategyClass(java.lang.String compactionStrategyClass)
```
    Description copied from interface: ColumnFamilyStoreMBean
    
    Sets the compaction strategy by class name
    
    Specified by:
    
    setCompactionStrategyClass in interface ColumnFamilyStoreMBean
    
    Parameters:
    compactionStrategyClass - the name of the compaction strategy class
  - getCompactionStrategyClass
```
public java.lang.String getCompactionStrategyClass()
```
    Description copied from interface: ColumnFamilyStoreMBean
    
    Gets the compaction strategy class name
    
    Specified by:
    
    getCompactionStrategyClass in interface ColumnFamilyStoreMBean
  - getCompressionParameters
```
public java.util.Map<java.lang.String,java.lang.String> getCompressionParameters()
```
    Description copied from interface: ColumnFamilyStoreMBean
    
    Get the compression parameters
    
    Specified by:
    
    getCompressionParameters in interface ColumnFamilyStoreMBean
  - setCompressionParameters
```
public void setCompressionParameters(java.util.Map<java.lang.String,java.lang.String> opts)
```
    Description copied from interface: ColumnFamilyStoreMBean
    
    Set the compression parameters
    
    Specified by:
    
    setCompressionParameters in interface ColumnFamilyStoreMBean
    
    Parameters:
    opts - map of string names to values
  - setCrcCheckChance
```
public void setCrcCheckChance(double crcCheckChance)
```
    Description copied from interface: ColumnFamilyStoreMBean
    
    Set new crc check chance
    
    Specified by:
    
    setCrcCheckChance in interface ColumnFamilyStoreMBean
  - invalidate
```
public void invalidate()
```
    call when dropping or renaming a CF. Performs mbean housekeeping and invalidates CFS to other operations
  - getMinRowSize
```
public long getMinRowSize()
```
    Specified by:
    
    getMinRowSize in interface ColumnFamilyStoreMBean
    
    Returns:
    the size of the smallest compacted row
    See Also:
    ColumnFamilyMetrics.minRowSize
  - getMaxRowSize
```
public long getMaxRowSize()
```
    Specified by:
    
    getMaxRowSize in interface ColumnFamilyStoreMBean
    
    Returns:
    the size of the largest compacted row
    See Also:
    ColumnFamilyMetrics.maxRowSize
  - getMeanRowSize
```
public long getMeanRowSize()
```
    Specified by:
    
    getMeanRowSize in interface ColumnFamilyStoreMBean
    
    Returns:
    the average row size across all the sstables
    See Also:
    ColumnFamilyMetrics.meanRowSize
  - getMeanColumns
```
public int getMeanColumns()
```
  - createColumnFamilyStore
```
public static ColumnFamilyStore createColumnFamilyStore(Keyspace keyspace,
                                        java.lang.String columnFamily,
                                        boolean loadSSTables)
```
  - createColumnFamilyStore
```
public static ColumnFamilyStore createColumnFamilyStore(Keyspace keyspace,
                                        java.lang.String columnFamily,
                                        IPartitioner partitioner,
                                        CFMetaData metadata)
```
  - scrubDataDirectories
```
public static void scrubDataDirectories(java.lang.String keyspaceName,
                        java.lang.String columnFamily)
```
    Removes unnecessary files from the cf directory at startup: these include temp files, orphans, zero-length files and compacted sstables. Files that cannot be recognized will be ignored.
  - removeUnfinishedCompactionLeftovers
```
public static void removeUnfinishedCompactionLeftovers(java.lang.String keyspace,
                                       java.lang.String columnfamily,
                                       java.util.Map<java.lang.Integer,java.util.UUID> unfinishedCompactions)
```
    Replacing compacted sstables is atomic as far as observers of DataTracker are concerned, but not on the filesystem: first the new sstables are renamed to "live" status (i.e., the tmp marker is removed), then their ancestors are removed. If an unclean shutdown happens at the right time, we can thus end up with both the new ones and their ancestors "live" in the system. This is harmless for normal data, but for counters it can cause overcounts. To prevent this, we record sstables being compacted in the system keyspace. If we find unfinished compactions, we remove the new ones (since those may be incomplete -- under LCS, we may create multiple sstables from any given ancestor).
  - initRowCache
```
public void initRowCache()
```
  - loadNewSSTables
```
public static void loadNewSSTables(java.lang.String ksName,
                   java.lang.String cfName)
```
    See #StorageService.loadNewSSTables(String, String) for more info
    
    Parameters:
    ksName - The keyspace name
    cfName - The columnFamily name
  - loadNewSSTables
```
public void loadNewSSTables()
```
    #Scan through Keyspace/ColumnFamily's data directory determine which SSTables should be loaded and load them
    
    Specified by:
    
    loadNewSSTables in interface ColumnFamilyStoreMBean
  - rebuildSecondaryIndex
```
public static void rebuildSecondaryIndex(java.lang.String ksName,
                         java.lang.String cfName,
                         java.lang.String... idxNames)
```
  - getColumnFamilyName
```
public java.lang.String getColumnFamilyName()
```
    Specified by:
    
    getColumnFamilyName in interface ColumnFamilyStoreMBean
    
    Returns:
    the name of the column family
  - getTempSSTablePath
```
public java.lang.String getTempSSTablePath(java.io.File directory)
```
  - switchMemtable
```
public java.util.concurrent.Future<?> switchMemtable(boolean writeCommitLog,
                                            boolean forceSwitch)
```
    Switch and flush the current memtable, if it was dirty. The forceSwitch flag allow to force switching the memtable even if it is clean (though in that case we don't flush, as there is no point).
  - forceFlush
```
public java.util.concurrent.Future<?> forceFlush()
```
    Returns:
    a future, with a guarantee that any data inserted prior to the forceFlush() call is fully flushed by the time future.get() returns. Never returns null.
  - forceBlockingFlush
```
public void forceBlockingFlush()
```
  - maybeUpdateRowCache
```
public void maybeUpdateRowCache(DecoratedKey key)
```
  - apply
```
public void apply(DecoratedKey key,
         ColumnFamily columnFamily,
         SecondaryIndexManager.Updater indexer)
```
    Insert/Update the column family for this key. Caller is responsible for acquiring Keyspace.switchLock param @ lock - lock that needs to be used. param @ key - key for update/insert param @ columnFamily - columnFamily changes
  - removeDeletedCF
```
public static ColumnFamily removeDeletedCF(ColumnFamily cf,
                           int gcBefore)
```
    Purges gc-able top-level and range tombstones, returning `cf` if there are any columns or tombstones left, null otherwise.
    
    Parameters:
    gcBefore - a timestamp (in seconds); tombstones with a localDeletionTime before this will be purged
  - removeDeleted
```
public static ColumnFamily removeDeleted(ColumnFamily cf,
                         int gcBefore)
```
    Removes deleted columns and purges gc-able tombstones.
    
    Returns:
    an updated `cf` if any columns or tombstones remain, null otherwise
  - removeDeleted
```
public static ColumnFamily removeDeleted(ColumnFamily cf,
                         int gcBefore,
                         SecondaryIndexManager.Updater indexer)
```
  - removeDeletedColumnsOnly
```
public static long removeDeletedColumnsOnly(ColumnFamily cf,
                            int gcBefore,
                            SecondaryIndexManager.Updater indexer)
```
    Removes only per-cell tombstones, cells that are shadowed by a row-level or range tombstone, or columns that have been dropped from the schema (for CQL3 tables only).
    
    Returns:
    the updated ColumnFamily
  - removeDeletedColumnsOnly
```
public static long removeDeletedColumnsOnly(ColumnFamily cf,
                            int gcBefore)
```
  - getOverlappingSSTables
```
public java.util.Set<SSTableReader> getOverlappingSSTables(java.util.Collection<SSTableReader> sstables)
```
    Parameters:
    sstables -
    
    Returns:
    sstables whose key range overlaps with that of the given sstables, not including itself. (The given sstables may or may not overlap with each other.)
  - getAndReferenceOverlappingSSTables
```
public java.util.Set<SSTableReader> getAndReferenceOverlappingSSTables(java.util.Collection<SSTableReader> sstables)
```
    like getOverlappingSSTables, but acquires references before returning
  - addSSTable
```
public void addSSTable(SSTableReader sstable)
```
  - addSSTables
```
public void addSSTables(java.util.Collection<SSTableReader> sstables)
```
  - getExpectedCompactedFileSize
```
public long getExpectedCompactedFileSize(java.lang.Iterable<SSTableReader> sstables,
                                OperationType operation)
```
    Calculate expected file size of SSTable after compaction. If operation type is CLEANUP and we're not dealing with an index sstable, then we calculate expected file size with checking token range to be eliminated. Otherwise, we just add up all the files' size, which is the worst case file size for compaction of all the list of files given.
    
    Parameters:
    sstables - SSTables to calculate expected compacted file size
    operation - Operation type
    
    Returns:
    Expected file size of SSTable after compaction
  - getMaxSizeFile
```
public SSTableReader getMaxSizeFile(java.lang.Iterable<SSTableReader> sstables)
```
  - forceCleanup
```
public void forceCleanup(CounterId.OneShotRenewer renewer)
                  throws java.util.concurrent.ExecutionException,
                         java.lang.InterruptedException
```
    Throws:
    
    java.util.concurrent.ExecutionException
    
    java.lang.InterruptedException
  - scrub
```
public void scrub(boolean disableSnapshot,
         boolean skipCorrupted)
           throws java.util.concurrent.ExecutionException,
                  java.lang.InterruptedException
```
    Throws:
    
    java.util.concurrent.ExecutionException
    
    java.lang.InterruptedException
  - sstablesRewrite
```
public void sstablesRewrite(boolean excludeCurrentVersion)
                     throws java.util.concurrent.ExecutionException,
                            java.lang.InterruptedException
```
    Throws:
    
    java.util.concurrent.ExecutionException
    
    java.lang.InterruptedException
  - markObsolete
```
public void markObsolete(java.util.Collection<SSTableReader> sstables,
                OperationType compactionType)
```
  - replaceCompactedSSTables
```
public void replaceCompactedSSTables(java.util.Collection<SSTableReader> sstables,
                            java.util.Collection<SSTableReader> replacements,
                            OperationType compactionType)
```
  - isValid
```
public boolean isValid()
```
  - getMemtableColumnsCount
```
public long getMemtableColumnsCount()
```
    Description copied from interface: ColumnFamilyStoreMBean
    
    Returns the total number of columns present in the memtable.
    
    Specified by:
    
    getMemtableColumnsCount in interface ColumnFamilyStoreMBean
    
    Returns:
    The number of columns.
    See Also:
    ColumnFamilyMetrics.memtableColumnsCount
  - getMemtableDataSize
```
public long getMemtableDataSize()
```
    Description copied from interface: ColumnFamilyStoreMBean
    
    Returns the total amount of data stored in the memtable, including column related overhead.
    
    Specified by:
    
    getMemtableDataSize in interface ColumnFamilyStoreMBean
    
    Returns:
    The size in bytes.
    See Also:
    ColumnFamilyMetrics.memtableDataSize
  - getTotalMemtableLiveSize
```
public long getTotalMemtableLiveSize()
```
  - getAllMemtablesLiveSize
```
public long getAllMemtablesLiveSize()
```
    Returns:
    the live size of all the memtables (the current active one and pending flush).
  - getTotalAllMemtablesLiveSize
```
public long getTotalAllMemtablesLiveSize()
```
    Returns:
    the size of all the memtables, including the pending flush ones and 2i memtables, if any.
  - getMemtableSwitchCount
```
public int getMemtableSwitchCount()
```
    Description copied from interface: ColumnFamilyStoreMBean
    
    Returns the number of times that a flush has resulted in the memtable being switched out.
    
    Specified by:
    
    getMemtableSwitchCount in interface ColumnFamilyStoreMBean
    
    Returns:
    the number of memtable switches
    See Also:
    ColumnFamilyMetrics.memtableSwitchCount
  - getDataTracker
```
public DataTracker getDataTracker()
```
    Package protected for access from the CompactionManager.
  - getSSTables
```
public java.util.Collection<SSTableReader> getSSTables()
```
  - getUncompactingSSTables
```
public java.util.Set<SSTableReader> getUncompactingSSTables()
```
  - getRecentSSTablesPerReadHistogram
```
public long[] getRecentSSTablesPerReadHistogram()
```
    Specified by:
    
    getRecentSSTablesPerReadHistogram in interface ColumnFamilyStoreMBean
    
    Returns:
    a histogram of the number of sstable data files accessed per read: reading this property resets it
    See Also:
    ColumnFamilyMetrics.recentSSTablesPerRead
  - getSSTablesPerReadHistogram
```
public long[] getSSTablesPerReadHistogram()
```
    Specified by:
    
    getSSTablesPerReadHistogram in interface ColumnFamilyStoreMBean
    
    Returns:
    a histogram of the number of sstable data files accessed per read
    See Also:
    ColumnFamilyMetrics.sstablesPerReadHistogram
  - getReadCount
```
public long getReadCount()
```
    Specified by:
    
    getReadCount in interface ColumnFamilyStoreMBean
    
    Returns:
    the number of read operations on this column family
    See Also:
    ColumnFamilyMetrics.readLatency
  - getRecentReadLatencyMicros
```
public double getRecentReadLatencyMicros()
```
    Specified by:
    
    getRecentReadLatencyMicros in interface ColumnFamilyStoreMBean
    
    Returns:
    average latency per read operation since the last call
    See Also:
    ColumnFamilyMetrics.readLatency
  - getLifetimeReadLatencyHistogramMicros
```
public long[] getLifetimeReadLatencyHistogramMicros()
```
    Specified by:
    
    getLifetimeReadLatencyHistogramMicros in interface ColumnFamilyStoreMBean
    
    Returns:
    an array representing the latency histogram
    See Also:
    ColumnFamilyMetrics.readLatency
  - getRecentReadLatencyHistogramMicros
```
public long[] getRecentReadLatencyHistogramMicros()
```
    Specified by:
    
    getRecentReadLatencyHistogramMicros in interface ColumnFamilyStoreMBean
    
    Returns:
    an array representing the latency histogram
    See Also:
    ColumnFamilyMetrics.readLatency
  - getTotalReadLatencyMicros
```
public long getTotalReadLatencyMicros()
```
    Specified by:
    
    getTotalReadLatencyMicros in interface ColumnFamilyStoreMBean
    
    Returns:
    total read latency (divide by getReadCount() for average)
    See Also:
    ColumnFamilyMetrics.readLatency
  - getPendingTasks
```
public int getPendingTasks()
```
    Specified by:
    
    getPendingTasks in interface ColumnFamilyStoreMBean
    
    Returns:
    the estimated number of tasks pending for this column family
    See Also:
    ColumnFamilyMetrics.pendingTasks
  - getWriteCount
```
public long getWriteCount()
```
    Specified by:
    
    getWriteCount in interface ColumnFamilyStoreMBean
    
    Returns:
    the number of write operations on this column family
    See Also:
    ColumnFamilyMetrics.writeLatency
  - getTotalWriteLatencyMicros
```
public long getTotalWriteLatencyMicros()
```
    Specified by:
    
    getTotalWriteLatencyMicros in interface ColumnFamilyStoreMBean
    
    Returns:
    total write latency (divide by getReadCount() for average)
    See Also:
    ColumnFamilyMetrics.writeLatency
  - getRecentWriteLatencyMicros
```
public double getRecentWriteLatencyMicros()
```
    Specified by:
    
    getRecentWriteLatencyMicros in interface ColumnFamilyStoreMBean
    
    Returns:
    average latency per write operation since the last call
    See Also:
    ColumnFamilyMetrics.writeLatency
  - getLifetimeWriteLatencyHistogramMicros
```
public long[] getLifetimeWriteLatencyHistogramMicros()
```
    Specified by:
    
    getLifetimeWriteLatencyHistogramMicros in interface ColumnFamilyStoreMBean
    
    Returns:
    an array representing the latency histogram
    See Also:
    ColumnFamilyMetrics.writeLatency
  - getRecentWriteLatencyHistogramMicros
```
public long[] getRecentWriteLatencyHistogramMicros()
```
    Specified by:
    
    getRecentWriteLatencyHistogramMicros in interface ColumnFamilyStoreMBean
    
    Returns:
    an array representing the latency histogram
    See Also:
    ColumnFamilyMetrics.writeLatency
  - getColumnFamily
```
public ColumnFamily getColumnFamily(DecoratedKey key,
                           java.nio.ByteBuffer start,
                           java.nio.ByteBuffer finish,
                           boolean reversed,
                           int limit,
                           long timestamp)
```
  - gcBefore
```
public int gcBefore(long now)
```
  - getColumnFamily
```
public ColumnFamily getColumnFamily(QueryFilter filter)
```
    get a list of columns starting from a given column, in a specified order. only the latest version of a column is returned.
    
    Returns:
    null if there is no data and no tombstones; otherwise a ColumnFamily
  - markCurrentSSTablesReferenced
```
public java.util.Collection<SSTableReader> markCurrentSSTablesReferenced()
```
    Get the current sstables, acquiring references on all of them. The caller is in charge of releasing the references on the sstables. See markCurrentViewReferenced() above.
  - markReferenced
```
public ColumnFamilyStore.ViewFragment markReferenced(DecoratedKey key)
```
    Returns:
    a ViewFragment containing the sstables and memtables that may need to be merged for the given @param key, according to the interval tree
  - markReferenced
```
public ColumnFamilyStore.ViewFragment markReferenced(AbstractBounds<RowPosition> rowBounds)
```
    Returns:
    a ViewFragment containing the sstables and memtables that may need to be merged for rows within @param rowBounds, inclusive, according to the interval tree.
  - markReferenced
```
public ColumnFamilyStore.ViewFragment markReferenced(java.util.Collection<AbstractBounds<RowPosition>> rowBoundsCollection)
```
    Returns:
    a ViewFragment containing the sstables and memtables that may need to be merged for rows for all of @param rowBoundsCollection, inclusive, according to the interval tree.
  - getSSTablesForKey
```
public java.util.List<java.lang.String> getSSTablesForKey(java.lang.String key)
```
    Description copied from interface: ColumnFamilyStoreMBean
    
    Returns a list of filenames that contain the given key on this node
    
    Specified by:
    
    getSSTablesForKey in interface ColumnFamilyStoreMBean
    
    Returns:
    list of filenames containing the key
  - getTopLevelColumns
```
public ColumnFamily getTopLevelColumns(QueryFilter filter,
                              int gcBefore)
```
  - cleanupCache
```
public void cleanupCache()
```
  - getRangeSlice
```
public java.util.List<Row> getRangeSlice(AbstractBounds<RowPosition> range,
                                java.util.List<org.apache.cassandra.thrift.IndexExpression> rowFilter,
                                IDiskAtomFilter columnFilter,
                                int maxResults)
```
  - getRangeSlice
```
public java.util.List<Row> getRangeSlice(AbstractBounds<RowPosition> range,
                                java.util.List<org.apache.cassandra.thrift.IndexExpression> rowFilter,
                                IDiskAtomFilter columnFilter,
                                int maxResults,
                                long now)
```
  - makeExtendedFilter
```
public ExtendedFilter makeExtendedFilter(AbstractBounds<RowPosition> keyRange,
                                SliceQueryFilter columnRange,
                                java.nio.ByteBuffer columnStart,
                                java.nio.ByteBuffer columnStop,
                                java.util.List<org.apache.cassandra.thrift.IndexExpression> rowFilter,
                                int maxResults,
                                boolean countCQL3Rows,
                                long now)
```
    Allows generic range paging with the slice column filter. Typically, suppose we have rows A, B, C ... Z having each some columns in [1, 100]. And suppose we want to page through the query that for all rows returns the columns within [25, 75]. For that, we need to be able to do a range slice starting at (row r, column c) and ending at (row Z, column 75), *but* that only return columns in [25, 75]. That is what this method allows. The columnRange is the "window" of columns we are interested in each row, and columnStart (resp. columnEnd) is the start (resp. end) for the first (resp. last) requested row.
  - getRangeSlice
```
public java.util.List<Row> getRangeSlice(AbstractBounds<RowPosition> range,
                                java.util.List<org.apache.cassandra.thrift.IndexExpression> rowFilter,
                                IDiskAtomFilter columnFilter,
                                int maxResults,
                                long now,
                                boolean countCQL3Rows,
                                boolean isPaging)
```
  - makeExtendedFilter
```
public ExtendedFilter makeExtendedFilter(AbstractBounds<RowPosition> range,
                                IDiskAtomFilter columnFilter,
                                java.util.List<org.apache.cassandra.thrift.IndexExpression> rowFilter,
                                int maxResults,
                                boolean countCQL3Rows,
                                boolean isPaging,
                                long timestamp)
```
  - getRangeSlice
```
public java.util.List<Row> getRangeSlice(ExtendedFilter filter)
```
  - search
```
public java.util.List<Row> search(AbstractBounds<RowPosition> range,
                         java.util.List<org.apache.cassandra.thrift.IndexExpression> clause,
                         IDiskAtomFilter dataFilter,
                         int maxResults)
```
  - search
```
public java.util.List<Row> search(AbstractBounds<RowPosition> range,
                         java.util.List<org.apache.cassandra.thrift.IndexExpression> clause,
                         IDiskAtomFilter dataFilter,
                         int maxResults,
                         long now)
```
  - search
```
public java.util.List<Row> search(ExtendedFilter filter)
```
  - filter
```
public java.util.List<Row> filter(ColumnFamilyStore.AbstractScanIterator rowIterator,
                         ExtendedFilter filter)
```
  - getComparator
```
public AbstractType<?> getComparator()
```
  - snapshotWithoutFlush
```
public void snapshotWithoutFlush(java.lang.String snapshotName)
```
  - getSnapshotSSTableReader
```
public java.util.List<SSTableReader> getSnapshotSSTableReader(java.lang.String tag)
                                                       throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - snapshot
```
public void snapshot(java.lang.String snapshotName)
```
    Take a snap shot of this columnfamily store.
    
    Parameters:
    snapshotName - the name of the associated with the snapshot
  - snapshotExists
```
public boolean snapshotExists(java.lang.String snapshotName)
```
  - getSnapshotCreationTime
```
public long getSnapshotCreationTime(java.lang.String snapshotName)
```
  - clearSnapshot
```
public void clearSnapshot(java.lang.String snapshotName)
```
    Clear all the snapshots for a given column family.
    
    Parameters:
    snapshotName - the user supplied snapshot name. If left empty, all the snapshots will be cleaned.
  - getTotalDiskSpaceUsed
```
public long getTotalDiskSpaceUsed()
```
    Specified by:
    
    getTotalDiskSpaceUsed in interface ColumnFamilyStoreMBean
    
    Returns:
    total disk space used by SSTables belonging to this CF, including obsolete ones waiting to be GC'd
    See Also:
    ColumnFamilyMetrics.totalDiskSpaceUsed
  - getLiveDiskSpaceUsed
```
public long getLiveDiskSpaceUsed()
```
    Specified by:
    
    getLiveDiskSpaceUsed in interface ColumnFamilyStoreMBean
    
    Returns:
    disk space used by SSTables belonging to this CF
    See Also:
    ColumnFamilyMetrics.liveDiskSpaceUsed
  - getLiveSSTableCount
```
public int getLiveSSTableCount()
```
    Specified by:
    
    getLiveSSTableCount in interface ColumnFamilyStoreMBean
    
    Returns:
    the number of SSTables on disk for this CF
    See Also:
    ColumnFamilyMetrics.liveSSTableCount
  - getRawCachedRow
```
public ColumnFamily getRawCachedRow(DecoratedKey key)
```
    Returns:
    the cached row for @param key if it is already present in the cache. That is, unlike getThroughCache, it will not readAndCache the row if it is not present, nor are these calls counted in cache statistics. Note that this WILL cause deserialization of a SerializingCache row, so if all you need to know is whether a row is present or not, use containsCachedRow instead.
  - containsCachedRow
```
public boolean containsCachedRow(DecoratedKey key)
```
    Returns:
    true if @param key is contained in the row cache
  - invalidateCachedRow
```
public void invalidateCachedRow(RowCacheKey key)
```
  - invalidateCachedRow
```
public void invalidateCachedRow(DecoratedKey key)
```
  - forceMajorCompaction
```
public void forceMajorCompaction()
                          throws java.lang.InterruptedException,
                                 java.util.concurrent.ExecutionException
```
    Description copied from interface: ColumnFamilyStoreMBean
    
    force a major compaction of this column family
    
    Specified by:
    
    forceMajorCompaction in interface ColumnFamilyStoreMBean
    
    Throws:
    
    java.lang.InterruptedException
    
    java.util.concurrent.ExecutionException
  - all
```
public static java.lang.Iterable<ColumnFamilyStore> all()
```
  - keySamples
```
public java.lang.Iterable<DecoratedKey> keySamples(Range<Token> range)
```
  - clearUnsafe
```
public void clearUnsafe()
```
    For testing. No effort is made to clear historical or even the current memtables, nor for thread safety. All we do is wipe the sstable containers clean, while leaving the actual data files present on disk. (This allows tests to easily call loadNewSSTables on them.)
  - truncateBlocking
```
public void truncateBlocking()
```
    Truncate deletes the entire column family's data with no expensive tombstone creation
  - runWithCompactionsDisabled
```
public <V> V runWithCompactionsDisabled(java.util.concurrent.Callable<V> callable,
                               boolean interruptValidation)
```
  - markAllCompacting
```
public java.lang.Iterable<SSTableReader> markAllCompacting()
```
  - getBloomFilterFalsePositives
```
public long getBloomFilterFalsePositives()
```
    Specified by:
    
    getBloomFilterFalsePositives in interface ColumnFamilyStoreMBean
    
    See Also:
    ColumnFamilyMetrics.bloomFilterFalsePositives
  - getRecentBloomFilterFalsePositives
```
public long getRecentBloomFilterFalsePositives()
```
    Specified by:
    
    getRecentBloomFilterFalsePositives in interface ColumnFamilyStoreMBean
    
    See Also:
    ColumnFamilyMetrics.recentBloomFilterFalsePositives
  - getBloomFilterFalseRatio
```
public double getBloomFilterFalseRatio()
```
    Specified by:
    
    getBloomFilterFalseRatio in interface ColumnFamilyStoreMBean
    
    See Also:
    ColumnFamilyMetrics.bloomFilterFalseRatio
  - getRecentBloomFilterFalseRatio
```
public double getRecentBloomFilterFalseRatio()
```
    Specified by:
    
    getRecentBloomFilterFalseRatio in interface ColumnFamilyStoreMBean
    
    See Also:
    ColumnFamilyMetrics.recentBloomFilterFalseRatio
  - getBloomFilterDiskSpaceUsed
```
public long getBloomFilterDiskSpaceUsed()
```
    Specified by:
    
    getBloomFilterDiskSpaceUsed in interface ColumnFamilyStoreMBean
    
    See Also:
    ColumnFamilyMetrics.bloomFilterDiskSpaceUsed
  - getBloomFilterOffHeapMemoryUsed
```
public long getBloomFilterOffHeapMemoryUsed()
```
    Specified by:
    
    getBloomFilterOffHeapMemoryUsed in interface ColumnFamilyStoreMBean
    
    See Also:
    ColumnFamilyMetrics.bloomFilterOffHeapMemoryUsed
  - getIndexSummaryOffHeapMemoryUsed
```
public long getIndexSummaryOffHeapMemoryUsed()
```
    Specified by:
    
    getIndexSummaryOffHeapMemoryUsed in interface ColumnFamilyStoreMBean
    
    See Also:
    ColumnFamilyMetrics.indexSummaryOffHeapMemoryUsed
  - getCompressionMetadataOffHeapMemoryUsed
```
public long getCompressionMetadataOffHeapMemoryUsed()
```
    Specified by:
    
    getCompressionMetadataOffHeapMemoryUsed in interface ColumnFamilyStoreMBean
    
    See Also:
    ColumnFamilyMetrics.compressionMetadataOffHeapMemoryUsed
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - disableAutoCompaction
```
public void disableAutoCompaction()
```
  - enableAutoCompaction
```
public void enableAutoCompaction()
```
  - enableAutoCompaction
```
public void enableAutoCompaction(boolean waitForFutures)
```
    used for tests - to be able to check things after a minor compaction
    
    Parameters:
    waitForFutures - if we should block until autocompaction is done
  - isAutoCompactionDisabled
```
public boolean isAutoCompactionDisabled()
```
    Specified by:
    
    isAutoCompactionDisabled in interface ColumnFamilyStoreMBean
  - getCompactionStrategy
```
public AbstractCompactionStrategy getCompactionStrategy()
```
  - setCompactionThresholds
```
public void setCompactionThresholds(int minThreshold,
                           int maxThreshold)
```
    Description copied from interface: ColumnFamilyStoreMBean
    
    Sets the maximum and maximum number of SSTables in queue before compaction kicks off
    
    Specified by:
    
    setCompactionThresholds in interface ColumnFamilyStoreMBean
  - getMinimumCompactionThreshold
```
public int getMinimumCompactionThreshold()
```
    Description copied from interface: ColumnFamilyStoreMBean
    
    Gets the minimum number of sstables in queue before compaction kicks off
    
    Specified by:
    
    getMinimumCompactionThreshold in interface ColumnFamilyStoreMBean
  - setMinimumCompactionThreshold
```
public void setMinimumCompactionThreshold(int minCompactionThreshold)
```
    Description copied from interface: ColumnFamilyStoreMBean
    
    Sets the minimum number of sstables in queue before compaction kicks off
    
    Specified by:
    
    setMinimumCompactionThreshold in interface ColumnFamilyStoreMBean
  - getMaximumCompactionThreshold
```
public int getMaximumCompactionThreshold()
```
    Description copied from interface: ColumnFamilyStoreMBean
    
    Gets the maximum number of sstables in queue before compaction kicks off
    
    Specified by:
    
    getMaximumCompactionThreshold in interface ColumnFamilyStoreMBean
  - setMaximumCompactionThreshold
```
public void setMaximumCompactionThreshold(int maxCompactionThreshold)
```
    Description copied from interface: ColumnFamilyStoreMBean
    
    Sets the maximum number of sstables in queue before compaction kicks off
    
    Specified by:
    
    setMaximumCompactionThreshold in interface ColumnFamilyStoreMBean
  - getTombstonesPerSlice
```
public double getTombstonesPerSlice()
```
    Description copied from interface: ColumnFamilyStoreMBean
    
    Number of tombstoned cells retreived during the last slicequery
    
    Specified by:
    
    getTombstonesPerSlice in interface ColumnFamilyStoreMBean
  - getLiveCellsPerSlice
```
public double getLiveCellsPerSlice()
```
    Description copied from interface: ColumnFamilyStoreMBean
    
    Number of live cells retreived during the last slicequery
    
    Specified by:
    
    getLiveCellsPerSlice in interface ColumnFamilyStoreMBean
  - estimateKeys
```
public long estimateKeys()
```
    Specified by:
    
    estimateKeys in interface ColumnFamilyStoreMBean
  - getEstimatedRowSizeHistogram
```
public long[] getEstimatedRowSizeHistogram()
```
    Specified by:
    
    getEstimatedRowSizeHistogram in interface ColumnFamilyStoreMBean
    
    See Also:
    ColumnFamilyMetrics.estimatedRowSizeHistogram
  - getEstimatedColumnCountHistogram
```
public long[] getEstimatedColumnCountHistogram()
```
    Specified by:
    
    getEstimatedColumnCountHistogram in interface ColumnFamilyStoreMBean
    
    See Also:
    ColumnFamilyMetrics.estimatedColumnCountHistogram
  - getCompressionRatio
```
public double getCompressionRatio()
```
    Specified by:
    
    getCompressionRatio in interface ColumnFamilyStoreMBean
    
    See Also:
    ColumnFamilyMetrics.compressionRatio
  - isIndex
```
public boolean isIndex()
```
    true if this CFS contains secondary index data
  - internOrCopy
```
public java.nio.ByteBuffer internOrCopy(java.nio.ByteBuffer name,
                               Allocator allocator)
```
  - maybeIntern
```
public java.nio.ByteBuffer maybeIntern(java.nio.ByteBuffer name)
```
  - concatWithIndexes
```
public java.lang.Iterable<ColumnFamilyStore> concatWithIndexes()
```
  - getMemtablesPendingFlush
```
public java.util.Set<Memtable> getMemtablesPendingFlush()
```
  - getBuiltIndexes
```
public java.util.List<java.lang.String> getBuiltIndexes()
```
    Description copied from interface: ColumnFamilyStoreMBean
    
    Returns a list of the names of the built column indexes for current store
    
    Specified by:
    
    getBuiltIndexes in interface ColumnFamilyStoreMBean
    
    Returns:
    list of the index names
  - getUnleveledSSTables
```
public int getUnleveledSSTables()
```
    Specified by:
    
    getUnleveledSSTables in interface ColumnFamilyStoreMBean
    
    Returns:
    the number of SSTables in L0. Always return 0 if Leveled compaction is not enabled.
  - getSSTableCountPerLevel
```
public int[] getSSTableCountPerLevel()
```
    Specified by:
    
    getSSTableCountPerLevel in interface ColumnFamilyStoreMBean
    
    Returns:
    sstable count for each level. null unless leveled compaction is used. array index corresponds to level(int[0] is for level 0, ...).
  - oldestUnflushedMemtable
```
public long oldestUnflushedMemtable()
```
    Returns the creation time of the oldest memtable not fully flushed yet.
  - isEmpty
```
public boolean isEmpty()
```
  - discardSSTables
```
public ReplayPosition discardSSTables(long truncatedAt)
```
    Discard all SSTables that were created before given timestamp. Caller should first ensure that comapctions have quiesced.
    
    Parameters:
    truncatedAt - The timestamp of the truncation (all SSTables before that timestamp are going be marked as compacted)
    
    Returns:
    the most recent replay position of the truncated data
  - getDroppableTombstoneRatio
```
public double getDroppableTombstoneRatio()
```
    Description copied from interface: ColumnFamilyStoreMBean
    
    Get the ratio of droppable tombstones to real columns (and non-droppable tombstones)
    
    Specified by:
    
    getDroppableTombstoneRatio in interface ColumnFamilyStoreMBean
    
    Returns:
    ratio

Class ColumnFamilyStore

Nested Class Summary

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

postFlushExecutor

keyspace

name

metadata

partitioner

indexManager

internedNames

directories

metric

sampleLatencyNanos

Method Detail

reload

setCompactionStrategyClass

getCompactionStrategyClass

getCompressionParameters

setCompressionParameters

setCrcCheckChance

invalidate

getMinRowSize

getMaxRowSize

getMeanRowSize

getMeanColumns

createColumnFamilyStore

createColumnFamilyStore

scrubDataDirectories

removeUnfinishedCompactionLeftovers

initRowCache

loadNewSSTables

loadNewSSTables

rebuildSecondaryIndex

getColumnFamilyName

getTempSSTablePath

switchMemtable

forceFlush

forceBlockingFlush

maybeUpdateRowCache

apply

removeDeletedCF

removeDeleted

removeDeleted

removeDeletedColumnsOnly

removeDeletedColumnsOnly

getOverlappingSSTables

getAndReferenceOverlappingSSTables

addSSTable

addSSTables

getExpectedCompactedFileSize

getMaxSizeFile

forceCleanup

scrub

sstablesRewrite

markObsolete

replaceCompactedSSTables

isValid

getMemtableColumnsCount

getMemtableDataSize

getTotalMemtableLiveSize

getAllMemtablesLiveSize

getTotalAllMemtablesLiveSize

getMemtableSwitchCount

getDataTracker

getSSTables

getUncompactingSSTables

getRecentSSTablesPerReadHistogram

getSSTablesPerReadHistogram

getReadCount

getRecentReadLatencyMicros

getLifetimeReadLatencyHistogramMicros

getRecentReadLatencyHistogramMicros

getTotalReadLatencyMicros

getPendingTasks

getWriteCount

getTotalWriteLatencyMicros

getRecentWriteLatencyMicros