ColumnFamilyStore (apache-cassandra API)

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

All Implemented Interfaces:: ColumnFamilyStoreMBean, Memtable.Owner

public class ColumnFamilyStore
extends java.lang.Object
implements ColumnFamilyStoreMBean, Memtable.Owner

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`ColumnFamilyStore.FlushReason` Reason for initiating a memtable flush.
`static class`	`ColumnFamilyStore.RefViewFragment`
`static class`	`ColumnFamilyStore.ViewFragment`

Field Summary

Fields
Modifier and Type	Field and Description
`long`	`additionalWriteLatencyMicros`
`SecondaryIndexManager`	`indexManager`
`Keyspace`	`keyspace`
`TableMetadataRef`	`metadata`
`TableMetrics`	`metric`
`java.lang.String`	`name`
`OpOrder`	`readOrdering`
`long`	`sampleReadLatencyMicros`
`static java.lang.String`	`SNAPSHOT_DROP_PREFIX`
`static java.lang.String`	`SNAPSHOT_TRUNCATE_PREFIX`
`TopPartitionTracker`	`topPartitions`
`TableViews`	`viewManager`

Constructor Summary

Constructors
Constructor and Description
`ColumnFamilyStore(Keyspace keyspace, java.lang.String columnFamilyName, java.util.function.Supplier<? extends SSTableId> sstableIdGenerator, TableMetadataRef metadata, Directories directories, boolean loadSSTables, boolean registerBookeeping, boolean offline)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`static java.lang.Iterable<Memtable>`	`activeMemtables()`
`void`	`addSSTable(SSTableReader sstable)`
`void`	`addSSTables(java.util.Collection<SSTableReader> sstables)`
`static java.lang.Iterable<ColumnFamilyStore>`	`all()`
`void`	`apply(PartitionUpdate update, UpdateTransaction indexer, OpOrder.Group opGroup, CommitLogPosition commitLogPosition)` Insert/Update the column family for this key.
`void`	`beginLocalSampling(java.lang.String sampler, int capacity, int durationMillis)` begin sampling for a specific sampler with a given capacity.
`void`	`cleanupCache()`
`protected static void`	`clearEphemeralSnapshots(Directories directories)`
`void`	`clearSnapshot(java.lang.String snapshotName)` Clear all the snapshots for a given column family.
`void`	`clearUnsafe()` For testing.
`void`	`compactionDiskSpaceCheck(boolean enable)`
`java.lang.Iterable<ColumnFamilyStore>`	`concatWithIndexes()`
`boolean`	`containsCachedParition(DecoratedKey key)`
`static ColumnFamilyStore`	`createColumnFamilyStore(Keyspace keyspace, java.lang.String columnFamily, TableMetadataRef metadata, boolean loadSSTables)`
`static ColumnFamilyStore`	`createColumnFamilyStore(Keyspace keyspace, java.lang.String columnFamily, TableMetadataRef metadata, Directories directories, boolean loadSSTables, boolean registerBookkeeping, boolean offline)` This is only directly used by offline tools
`static ColumnFamilyStore`	`createColumnFamilyStore(Keyspace keyspace, TableMetadataRef metadata, boolean loadSSTables)`
`AbstractCompactionStrategy`	`createCompactionStrategyInstance(CompactionParams compactionParams)`
`Memtable`	`createMemtable(java.util.concurrent.atomic.AtomicReference<CommitLogPosition> commitLogUpperBound)`
`protected TableSnapshot`	`createSnapshot(java.lang.String tag, boolean ephemeral, DurationSpec.IntSecondsBound ttl, java.util.Set<SSTableReader> sstables, java.time.Instant creationTime)`
`SSTableMultiWriter`	`createSSTableMultiWriter(Descriptor descriptor, long keyCount, long repairedAt, TimeUUID pendingRepair, boolean isTransient, int sstableLevel, SerializationHeader header, LifecycleNewTracker lifecycleNewTracker)`
`SSTableMultiWriter`	`createSSTableMultiWriter(Descriptor descriptor, long keyCount, long repairedAt, TimeUUID pendingRepair, boolean isTransient, MetadataCollector metadataCollector, SerializationHeader header, LifecycleNewTracker lifecycleNewTracker)`
`DecoratedKey`	`decorateKey(java.nio.ByteBuffer key)`
`void`	`disableAutoCompaction()`
`void`	`discardSSTables(long truncatedAt)` Discard all SSTables that were created before given timestamp.
`Future<CommitLogPosition>`	`dumpMemtable()` Drops current memtable without flushing to disk.
`void`	`enableAutoCompaction()`
`void`	`enableAutoCompaction(boolean waitForFutures)` used for tests - to be able to check things after a minor compaction
`long`	`estimatedKeysForRange(Range<Token> range)`
`long`	`estimateKeys()`
`java.util.List<javax.management.openmbean.CompositeData>`	`finishLocalSampling(java.lang.String sampler, int count)`
`CommitLogPosition`	`forceBlockingFlush(ColumnFamilyStore.FlushReason reason)`
`CompactionManager.AllSSTableOpStatus`	`forceCleanup(int jobs)`
`void`	`forceCompactionForKey(DecoratedKey key)`
`void`	`forceCompactionForTokenRange(java.util.Collection<Range<Token>> tokenRanges)` Forces a major compaction of specified token ranges in this column family.
`void`	`forceCompactionForTokenRanges(java.lang.String... strings)` Forces a major compaction of specified token ranges in this column family.
`Future<CommitLogPosition>`	`forceFlush(ColumnFamilyStore.FlushReason reason)` Flush if there is unflushed data in the memtables
`Future<?>`	`forceFlush(CommitLogPosition flushIfDirtyBefore)` Flush if there is unflushed data that was written to the CommitLog before @param flushIfDirtyBefore (inclusive).
`void`	`forceMajorCompaction()`
`void`	`forceMajorCompaction(boolean splitOutput)` force a major compaction of this column family
`CompactionManager.AllSSTableOpStatus`	`garbageCollect(CompactionParams.TombstoneOption tombstoneOption, int jobs)`
`int`	`gcBefore(int nowInSec)`
`Refs<SSTableReader>`	`getAndReferenceOverlappingLiveSSTables(java.lang.Iterable<SSTableReader> sstables)` like getOverlappingSSTables, but acquires references before returning
`static java.lang.Runnable`	`getBackgroundCompactionTaskSubmitter()`
`java.util.List<java.lang.String>`	`getBuiltIndexes()` Returns a list of the names of the built column indexes for current store
`ClockAndCount`	`getCachedCounter(java.nio.ByteBuffer partitionKey, Clustering<?> clustering, ColumnMetadata column, CellPath path)`
`static java.lang.String`	`getColumnFamilieMBeanName(java.lang.String ks, java.lang.String name, boolean isIndex)`
`java.lang.String`	`getColumnFamilyName()` Deprecated.
`java.util.Map<java.lang.String,java.lang.String>`	`getCompactionParameters()`
`java.lang.String`	`getCompactionParametersJson()`
`CompactionStrategyManager`	`getCompactionStrategyManager()`
`ClusteringComparator`	`getComparator()`
`java.util.Map<java.lang.String,java.lang.String>`	`getCompressionParameters()` Get the compression parameters
`java.lang.String`	`getCompressionParametersJson()`
`java.lang.Double`	`getCrcCheckChance()`
`Memtable`	`getCurrentMemtable()` Get the current memtable for this owner.
`java.util.List<java.lang.String>`	`getDataPaths()`
`Directories`	`getDirectories()`
`DiskBoundaries`	`getDiskBoundaries()`
`double`	`getDroppableTombstoneRatio()` Get the ratio of droppable tombstones to real columns (and non-droppable tombstones)
`long`	`getExpectedCompactedFileSize(java.lang.Iterable<SSTableReader> sstables, OperationType operation)` Calculate expected file size of SSTable after compaction.
`static ColumnFamilyStore`	`getIfExists(java.lang.String ksName, java.lang.String cfName)` Returns a ColumnFamilyStore by ksname and cfname if it exists, null otherwise Differently from others, this method does not throw exception if the keyspace or table does not exist.
`static ColumnFamilyStore`	`getIfExists(TableId id)` Returns a ColumnFamilyStore by id if it exists, null otherwise Differently from others, this method does not throw exception if the table does not exist.
`java.lang.Iterable<Memtable>`	`getIndexMemtables()` Collect the index memtables flushed together with this.
`int`	`getLevelFanoutSize()`
`java.util.Set<SSTableReader>`	`getLiveSSTables()`
`int`	`getMaximumCompactionThreshold()` Gets the maximum number of sstables in queue before compaction kicks off
`SSTableReader`	`getMaxSizeFile(java.lang.Iterable<SSTableReader> sstables)`
`int`	`getMeanEstimatedCellPerPartitionCount()`
`double`	`getMeanPartitionSize()`
`int`	`getMeanRowCount()`
`int`	`getMinimumCompactionThreshold()` Gets the minimum number of sstables in queue before compaction kicks off
`boolean`	`getNeverPurgeTombstones()`
`java.util.Collection<SSTableReader>`	`getOverlappingLiveSSTables(java.lang.Iterable<SSTableReader> sstables)`
`IPartitioner`	`getPartitioner()`
`PaxosRepairHistory`	`getPaxosRepairHistory()`
`PaxosRepairHistory`	`getPaxosRepairHistoryForRanges(java.util.Collection<Range<Token>> ranges)`
`Ballot`	`getPaxosRepairLowBound(DecoratedKey key)`
`java.util.Map<TimeUUID,PendingStat>`	`getPendingRepairStats()`
`long[]`	`getPerLevelSizeBytes()`
`CachedPartition`	`getRawCachedPartition(DecoratedKey key)`
`TableRepairManager`	`getRepairManager()`
`Refs<SSTableReader>`	`getSnapshotSSTableReaders(java.lang.String tag)`
`int[]`	`getSSTableCountPerLevel()`
`java.lang.Iterable<SSTableReader>`	`getSSTables(SSTableSet sstableSet)`
`java.util.List<java.lang.String>`	`getSSTablesForKey(java.lang.String key)` Returns a list of filenames that contain the given key on this node
`java.util.List<java.lang.String>`	`getSSTablesForKey(java.lang.String key, boolean hexFormat)` Returns a list of filenames that contain the given key on this node
`TableStreamManager`	`getStreamManager()`
`static java.lang.String`	`getTableMBeanName(java.lang.String ks, java.lang.String name, boolean isIndex)`
`java.lang.String`	`getTableName()`
`java.util.Map<java.lang.String,java.lang.Long>`	`getTopSizePartitions()`
`java.lang.Long`	`getTopSizePartitionsLastUpdate()`
`java.util.Map<java.lang.String,java.lang.Long>`	`getTopTombstonePartitions()`
`java.lang.Long`	`getTopTombstonePartitionsLastUpdate()`
`Tracker`	`getTracker()` Package protected for access from the CompactionManager.
`java.lang.Iterable<SSTableReader>`	`getUncompactingSSTables()`
`int`	`getUnleveledSSTables()`
`TableWriteHandler`	`getWriteHandler()`
`boolean`	`hasMisplacedSSTables()` Check SSTables whether or not they are misplaced.
`java.util.List<java.lang.String>`	`importNewSSTables(java.util.Set<java.lang.String> srcPaths, boolean resetLevel, boolean clearRepaired, boolean verifySSTables, boolean verifyTokens, boolean invalidateCaches, boolean extendedVerify)` Load new sstables from the given directory
`java.util.List<java.lang.String>`	`importNewSSTables(java.util.Set<java.lang.String> srcPaths, boolean resetLevel, boolean clearRepaired, boolean verifySSTables, boolean verifyTokens, boolean invalidateCaches, boolean extendedVerify, boolean copyData)` #Load new sstables from the given directory
`void`	`invalidate()` call when dropping or renaming a CF.
`void`	`invalidate(boolean expectMBean)`
`void`	`invalidate(boolean expectMBean, boolean dropData)`
`void`	`invalidateCachedPartition(DecoratedKey key)`
`void`	`invalidateCachedPartition(RowCacheKey key)`
`int`	`invalidateCounterCache(java.util.Collection<Bounds<Token>> boundsToInvalidate)`
`void`	`invalidateLocalRanges()`
`int`	`invalidateRowCache(java.util.Collection<Bounds<Token>> boundsToInvalidate)`
`boolean`	`isAutoCompactionDisabled()`
`boolean`	`isCompactionDiskSpaceCheckEnabled()`
`boolean`	`isCounterCacheEnabled()`
`boolean`	`isEmpty()`
`boolean`	`isFilterFullyCoveredBy(ClusteringIndexFilter filter, DataLimits limits, CachedPartition cached, int nowInSec, boolean enforceStrictLiveness)`
`boolean`	`isIndex()` true if this CFS contains secondary index data
`boolean`	`isKeyCacheEnabled()`
`boolean`	`isRowCacheEnabled()`
`boolean`	`isValid()`
`java.lang.Iterable<DecoratedKey>`	`keySamples(Range<Token> range)`
`java.util.Map<java.lang.String,TableSnapshot>`	`listSnapshots()`
`void`	`loadNewSSTables()` Deprecated.
`static void`	`loadNewSSTables(java.lang.String ksName, java.lang.String cfName)` See #`StorageService.importNewSSTables` for more info
`ShardBoundaries`	`localRangeSplits(int shardCount)` Construct a list of boundaries that split the locally-owned ranges into the given number of shards, splitting the owned space evenly.
`LifecycleTransaction`	`markAllCompacting(OperationType operationType)`
`void`	`markObsolete(java.util.Collection<SSTableReader> sstables, OperationType compactionType)`
`boolean`	`memtableWritesAreDurable()`
`TableMetadata`	`metadata()`
`static TableMetrics`	`metricsFor(TableId tableId)`
`Descriptor`	`newSSTableDescriptor(File directory)`
`Descriptor`	`newSSTableDescriptor(File directory, SSTableFormat.Type format)`
`Descriptor`	`newSSTableDescriptor(File directory, Version version, SSTableFormat.Type format)`
`void`	`onPaxosRepairComplete(java.util.Collection<Range<Token>> ranges, Ballot highBallot)`
`void`	`putCachedCounter(java.nio.ByteBuffer partitionKey, Clustering<?> clustering, ColumnMetadata column, CellPath path, ClockAndCount clockAndCount)`
`boolean`	`rebuildOnFailedScrub(java.lang.Throwable failure)` CASSANDRA-5174 : For an index cfs we may be able to discard everything and just rebuild the index when a scrub fails.
`void`	`rebuildSecondaryIndex(java.lang.String idxName)`
`static void`	`rebuildSecondaryIndex(java.lang.String ksName, java.lang.String cfName, java.lang.String... idxNames)`
`CleanupSummary`	`releaseRepairData(java.util.Collection<TimeUUID> sessions, boolean force)` promotes (or demotes) data attached to an incremental repair session that has either completed successfully, or failed
`void`	`reload()`
`CompactionManager.AllSSTableOpStatus`	`relocateSSTables(int jobs)`
`<V> V`	`runWithCompactionsDisabled(java.util.concurrent.Callable<V> callable, boolean interruptValidation, boolean interruptViews)`
`<V> V`	`runWithCompactionsDisabled(java.util.concurrent.Callable<V> callable, com.google.common.base.Predicate<SSTableReader> sstablesPredicate, boolean interruptValidation, boolean interruptViews, boolean interruptIndexes)` Runs callable with compactions paused and compactions including sstables matching sstablePredicate stopped
`CompactionManager.AllSSTableOpStatus`	`scrub(boolean disableSnapshot, boolean skipCorrupted, boolean reinsertOverflowedTTL, boolean alwaysFail, boolean checkData, int jobs)`
`CompactionManager.AllSSTableOpStatus`	`scrub(boolean disableSnapshot, boolean skipCorrupted, boolean checkData, boolean reinsertOverflowedTTL, int jobs)`
`static void`	`scrubDataDirectories(TableMetadata metadata)` Removes unnecessary files from the cf directory at startup: these include temp files, orphans, zero-length files and compacted sstables.
`ColumnFamilyStore.ViewFragment`	`select(com.google.common.base.Function<View,java.lang.Iterable<SSTableReader>> filter)`
`ColumnFamilyStore.RefViewFragment`	`selectAndReference(com.google.common.base.Function<View,java.lang.Iterable<SSTableReader>> filter)`
`void`	`setCompactionParameters(java.util.Map<java.lang.String,java.lang.String> options)` Sets the compaction parameters locally for this node Note that this will be set until an ALTER with compaction = {..} is executed or the node is restarted
`void`	`setCompactionParametersJson(java.lang.String options)` Sets the compaction parameters locally for this node Note that this will be set until an ALTER with compaction = {..} is executed or the node is restarted
`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 locally for this node
`void`	`setCompressionParametersJson(java.lang.String options)`
`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`	`setNeverPurgeTombstones(boolean value)`
`static void`	`shutdownExecutorsAndWait(long timeout, java.util.concurrent.TimeUnit unit)`
`static void`	`shutdownPostFlushExecutor()`
`Future<CommitLogPosition>`	`signalFlushRequired(Memtable memtable, ColumnFamilyStore.FlushReason reason)` Signal to the owner that a flush is required (e.g.
`TableSnapshot`	`snapshot(java.lang.String snapshotName)` Take a snap shot of this columnfamily store.
`TableSnapshot`	`snapshot(java.lang.String snapshotName, boolean skipMemtable, DurationSpec.IntSecondsBound ttl, com.google.common.util.concurrent.RateLimiter rateLimiter, java.time.Instant creationTime)` Take a snap shot of this columnfamily store.
`TableSnapshot`	`snapshot(java.lang.String snapshotName, DurationSpec.IntSecondsBound ttl)`
`TableSnapshot`	`snapshot(java.lang.String snapshotName, com.google.common.base.Predicate<SSTableReader> predicate, boolean ephemeral, boolean skipMemtable)`
`TableSnapshot`	`snapshot(java.lang.String snapshotName, com.google.common.base.Predicate<SSTableReader> predicate, boolean ephemeral, boolean skipMemtable, DurationSpec.IntSecondsBound ttl, com.google.common.util.concurrent.RateLimiter rateLimiter, java.time.Instant creationTime)`
`boolean`	`snapshotExists(java.lang.String snapshotName)`
`TableSnapshot`	`snapshotWithoutMemtable(java.lang.String snapshotName)`
`TableSnapshot`	`snapshotWithoutMemtable(java.lang.String snapshotName, java.time.Instant creationTime)`
`TableSnapshot`	`snapshotWithoutMemtable(java.lang.String snapshotName, com.google.common.base.Predicate<SSTableReader> predicate, boolean ephemeral, DurationSpec.IntSecondsBound ttl, com.google.common.util.concurrent.RateLimiter rateLimiter, java.time.Instant creationTime)`
`CompactionManager.AllSSTableOpStatus`	`sstablesRewrite(boolean skipIfCurrentVersion, long skipIfNewerThanTimestamp, boolean skipIfCompressionMatches, int jobs)` Rewrites all SSTables according to specified parameters
`boolean`	`streamFromMemtable()`
`boolean`	`streamToMemtable()`
`boolean`	`supportsEarlyOpen()`
`Future<CommitLogPosition>`	`switchMemtable(ColumnFamilyStore.FlushReason reason)`
`Future<CommitLogPosition>`	`switchMemtableIfCurrent(Memtable memtable, ColumnFamilyStore.FlushReason reason)` Switches the memtable iff the live memtable is the one provided
`void`	`syncPaxosRepairHistory(PaxosRepairHistory sync, boolean flush)`
`java.lang.String`	`toString()`
`long`	`trueSnapshotsSize()`
`void`	`truncateBlocking()`
`void`	`truncateBlockingWithoutSnapshot()`
`void`	`unloadCf()`
`void`	`updateSpeculationThreshold()`
`CompactionManager.AllSSTableOpStatus`	`verify(Verifier.Options options)`
`void`	`writeAndAddMemtableRanges(TimeUUID repairSessionID, java.util.function.Supplier<java.util.Collection<Range<PartitionPosition>>> rangesSupplier, Refs<SSTableReader> placeIntoRefs)`
`boolean`	`writesShouldSkipCommitLog()`

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

Field Detail

SNAPSHOT_TRUNCATE_PREFIX

public static final java.lang.String SNAPSHOT_TRUNCATE_PREFIX

See Also:: Constant Field Values

SNAPSHOT_DROP_PREFIX

public static final java.lang.String SNAPSHOT_DROP_PREFIX

See Also:: Constant Field Values

keyspace
```
public final Keyspace keyspace
```

name
```
public final java.lang.String name
```

metadata
```
public final TableMetadataRef metadata
```

readOrdering
```
public final OpOrder readOrdering
```

indexManager

public final SecondaryIndexManager indexManager

viewManager
```
public final TableViews viewManager
```

metric
```
public final TableMetrics metric
```

sampleReadLatencyMicros

public volatile long sampleReadLatencyMicros

additionalWriteLatencyMicros

public volatile long additionalWriteLatencyMicros

topPartitions

public final TopPartitionTracker topPartitions

Constructor Detail

ColumnFamilyStore

public ColumnFamilyStore(Keyspace keyspace,
                         java.lang.String columnFamilyName,
                         java.util.function.Supplier<? extends SSTableId> sstableIdGenerator,
                         TableMetadataRef metadata,
                         Directories directories,
                         boolean loadSSTables,
                         boolean registerBookeeping,
                         boolean offline)

Method Detail

shutdownPostFlushExecutor

public static void shutdownPostFlushExecutor()
                                      throws java.lang.InterruptedException

Throws:: java.lang.InterruptedException

shutdownExecutorsAndWait

public static void shutdownExecutorsAndWait(long timeout,
                                            java.util.concurrent.TimeUnit unit)
                                     throws java.lang.InterruptedException,
                                            java.util.concurrent.TimeoutException

Throws:: java.lang.InterruptedException; java.util.concurrent.TimeoutException

reload
```
public void reload()
```

getBackgroundCompactionTaskSubmitter

public static java.lang.Runnable getBackgroundCompactionTaskSubmitter()

getCompactionParameters
```
public java.util.Map<java.lang.String,java.lang.String> getCompactionParameters()
```
Specified by:

getCompactionParameters in interface ColumnFamilyStoreMBean

getCompactionParametersJson
```
public java.lang.String getCompactionParametersJson()
```
Specified by:

getCompactionParametersJson in interface ColumnFamilyStoreMBean

setCompactionParameters
```
public void setCompactionParameters(java.util.Map<java.lang.String,java.lang.String> options)
```
Description copied from interface: ColumnFamilyStoreMBean

Sets the compaction parameters locally for this node Note that this will be set until an ALTER with compaction = {..} is executed or the node is restarted

Specified by:

setCompactionParameters in interface ColumnFamilyStoreMBean

Parameters:

options - compaction options map

setCompactionParametersJson
```
public void setCompactionParametersJson(java.lang.String options)
```
Description copied from interface: ColumnFamilyStoreMBean

Sets the compaction parameters locally for this node Note that this will be set until an ALTER with compaction = {..} is executed or the node is restarted

Specified by:

setCompactionParametersJson in interface ColumnFamilyStoreMBean

Parameters:

options - compaction options with the same syntax as when doing ALTER ... WITH compaction = {..}

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

getCompressionParametersJson
```
public java.lang.String getCompressionParametersJson()
```
Specified by:

getCompressionParametersJson 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 locally for this node

Specified by:

setCompressionParameters in interface ColumnFamilyStoreMBean

Parameters:

opts - map of string names to values

setCompressionParametersJson
```
public void setCompressionParametersJson(java.lang.String options)
```
Specified by:

setCompressionParametersJson in interface ColumnFamilyStoreMBean

getTableMBeanName

public static java.lang.String getTableMBeanName(java.lang.String ks,
                                                 java.lang.String name,
                                                 boolean isIndex)

getColumnFamilieMBeanName

public static java.lang.String getColumnFamilieMBeanName(java.lang.String ks,
                                                         java.lang.String name,
                                                         boolean isIndex)

updateSpeculationThreshold

public void updateSpeculationThreshold()

getWriteHandler

public TableWriteHandler getWriteHandler()

getStreamManager

public TableStreamManager getStreamManager()

getRepairManager

public TableRepairManager getRepairManager()

metadata
```
public TableMetadata metadata()
```

getDirectories
```
public Directories getDirectories()
```

getDataPaths

public java.util.List<java.lang.String> getDataPaths()
                                              throws java.io.IOException

Specified by:: getDataPaths in interface ColumnFamilyStoreMBean
Throws:: java.io.IOException

writesShouldSkipCommitLog

public boolean writesShouldSkipCommitLog()

memtableWritesAreDurable

public boolean memtableWritesAreDurable()

streamToMemtable
```
public boolean streamToMemtable()
```

streamFromMemtable
```
public boolean streamFromMemtable()
```

createSSTableMultiWriter

public SSTableMultiWriter createSSTableMultiWriter(Descriptor descriptor,
                                                   long keyCount,
                                                   long repairedAt,
                                                   TimeUUID pendingRepair,
                                                   boolean isTransient,
                                                   int sstableLevel,
                                                   SerializationHeader header,
                                                   LifecycleNewTracker lifecycleNewTracker)

createSSTableMultiWriter

public SSTableMultiWriter createSSTableMultiWriter(Descriptor descriptor,
                                                   long keyCount,
                                                   long repairedAt,
                                                   TimeUUID pendingRepair,
                                                   boolean isTransient,
                                                   MetadataCollector metadataCollector,
                                                   SerializationHeader header,
                                                   LifecycleNewTracker lifecycleNewTracker)

supportsEarlyOpen
```
public boolean supportsEarlyOpen()
```

invalidate
```
public void invalidate()
```
call when dropping or renaming a CF. Performs mbean housekeeping and invalidates CFS to other operations

invalidate

public void invalidate(boolean expectMBean)

invalidate

public void invalidate(boolean expectMBean,
                       boolean dropData)

createColumnFamilyStore

public static ColumnFamilyStore createColumnFamilyStore(Keyspace keyspace,
                                                        TableMetadataRef metadata,
                                                        boolean loadSSTables)

createColumnFamilyStore

public static ColumnFamilyStore createColumnFamilyStore(Keyspace keyspace,
                                                        java.lang.String columnFamily,
                                                        TableMetadataRef metadata,
                                                        boolean loadSSTables)

createColumnFamilyStore

public static ColumnFamilyStore createColumnFamilyStore(Keyspace keyspace,
                                                        java.lang.String columnFamily,
                                                        TableMetadataRef metadata,
                                                        Directories directories,
                                                        boolean loadSSTables,
                                                        boolean registerBookkeeping,
                                                        boolean offline)

This is only directly used by offline tools

scrubDataDirectories
```
public static void scrubDataDirectories(TableMetadata metadata)
                                 throws StartupException
```
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.

Throws:

StartupException

loadNewSSTables
```
public static void loadNewSSTables(java.lang.String ksName,
                                   java.lang.String cfName)
```
See #StorageService.importNewSSTables for more info

Parameters:

ksName - The keyspace name

cfName - The columnFamily name

loadNewSSTables
```
@Deprecated
public void loadNewSSTables()
```
Deprecated.

Specified by:

loadNewSSTables in interface ColumnFamilyStoreMBean

importNewSSTables
```
public java.util.List<java.lang.String> importNewSSTables(java.util.Set<java.lang.String> srcPaths,
                                                          boolean resetLevel,
                                                          boolean clearRepaired,
                                                          boolean verifySSTables,
                                                          boolean verifyTokens,
                                                          boolean invalidateCaches,
                                                          boolean extendedVerify,
                                                          boolean copyData)
```
#Load new sstables from the given directory

Specified by:

importNewSSTables in interface ColumnFamilyStoreMBean

Parameters:

srcPaths - the path to the new sstables - if it is an empty set, the data directories will be scanned

resetLevel - if the level should be reset to 0 on the new sstables

clearRepaired - if repaired info should be wiped from the new sstables

verifySSTables - if the new sstables should be verified that they are not corrupt

verifyTokens - if the tokens in the new sstables should be verified that they are owned by the current node

invalidateCaches - if row cache should be invalidated for the keys in the new sstables

extendedVerify - if we should run an extended verify checking all values in the new sstables

copyData - if we should copy data from source paths instead of moving them

Returns:

list of failed import directories

importNewSSTables
```
public java.util.List<java.lang.String> importNewSSTables(java.util.Set<java.lang.String> srcPaths,
                                                          boolean resetLevel,
                                                          boolean clearRepaired,
                                                          boolean verifySSTables,
                                                          boolean verifyTokens,
                                                          boolean invalidateCaches,
                                                          boolean extendedVerify)
```
Description copied from interface: ColumnFamilyStoreMBean

Load new sstables from the given directory

Specified by:

importNewSSTables in interface ColumnFamilyStoreMBean

Parameters:

srcPaths - the path to the new sstables - if it is an empty set, the data directories will be scanned

resetLevel - if the level should be reset to 0 on the new sstables

clearRepaired - if repaired info should be wiped from the new sstables

verifySSTables - if the new sstables should be verified that they are not corrupt

verifyTokens - if the tokens in the new sstables should be verified that they are owned by the current node

invalidateCaches - if row cache should be invalidated for the keys in the new sstables

extendedVerify - if we should run an extended verify checking all values in the new sstables

Returns:

list of failed import directories

rebuildSecondaryIndex

public void rebuildSecondaryIndex(java.lang.String idxName)

rebuildSecondaryIndex

public static void rebuildSecondaryIndex(java.lang.String ksName,
                                         java.lang.String cfName,
                                         java.lang.String... idxNames)

createCompactionStrategyInstance

public AbstractCompactionStrategy createCompactionStrategyInstance(CompactionParams compactionParams)

getColumnFamilyName
```
@Deprecated
public java.lang.String getColumnFamilyName()
```
Deprecated.

Specified by:

getColumnFamilyName in interface ColumnFamilyStoreMBean

Returns:

the name of the column family

getTableName
```
public java.lang.String getTableName()
```
Specified by:

getTableName in interface ColumnFamilyStoreMBean

newSSTableDescriptor

public Descriptor newSSTableDescriptor(File directory)

newSSTableDescriptor

public Descriptor newSSTableDescriptor(File directory,
                                       SSTableFormat.Type format)

newSSTableDescriptor

public Descriptor newSSTableDescriptor(File directory,
                                       Version version,
                                       SSTableFormat.Type format)

switchMemtableIfCurrent

public Future<CommitLogPosition> switchMemtableIfCurrent(Memtable memtable,
                                                         ColumnFamilyStore.FlushReason reason)

Switches the memtable iff the live memtable is the one provided

Parameters:: memtable -

switchMemtable

public Future<CommitLogPosition> switchMemtable(ColumnFamilyStore.FlushReason reason)

forceFlush
```
public Future<CommitLogPosition> forceFlush(ColumnFamilyStore.FlushReason reason)
```
Flush if there is unflushed data in the memtables

Returns:

a Future yielding the commit log position that can be guaranteed to have been successfully written to sstables for this table once the future completes

forceFlush
```
public Future<?> forceFlush(CommitLogPosition flushIfDirtyBefore)
```
Flush if there is unflushed data that was written to the CommitLog before @param flushIfDirtyBefore (inclusive).

Returns:

a Future yielding the commit log position that can be guaranteed to have been successfully written to sstables for this table once the future completes

forceBlockingFlush

public CommitLogPosition forceBlockingFlush(ColumnFamilyStore.FlushReason reason)

createMemtable

public Memtable createMemtable(java.util.concurrent.atomic.AtomicReference<CommitLogPosition> commitLogUpperBound)

signalFlushRequired

public Future<CommitLogPosition> signalFlushRequired(Memtable memtable,
                                                     ColumnFamilyStore.FlushReason reason)

Description copied from interface: Memtable.Owner

Signal to the owner that a flush is required (e.g. in response to hitting space limits)

Specified by:: signalFlushRequired in interface Memtable.Owner

getCurrentMemtable
```
public Memtable getCurrentMemtable()
```
Description copied from interface: Memtable.Owner

Get the current memtable for this owner. Used to avoid capturing memtable in scheduled flush tasks.

Specified by:

getCurrentMemtable in interface Memtable.Owner

activeMemtables

public static java.lang.Iterable<Memtable> activeMemtables()

getIndexMemtables
```
public java.lang.Iterable<Memtable> getIndexMemtables()
```
Description copied from interface: Memtable.Owner

Collect the index memtables flushed together with this. Used to accurately calculate memory that would be freed by a flush.

Specified by:

getIndexMemtables in interface Memtable.Owner

apply

public void apply(PartitionUpdate update,
                  UpdateTransaction indexer,
                  OpOrder.Group opGroup,
                  CommitLogPosition commitLogPosition)

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

localRangeSplits
```
public ShardBoundaries localRangeSplits(int shardCount)
```
Description copied from interface: Memtable.Owner

Construct a list of boundaries that split the locally-owned ranges into the given number of shards, splitting the owned space evenly. It is up to the memtable to use this information. Any changes in the ring structure (e.g. added or removed nodes) will invalidate the splits; in such a case the memtable will be sent a Memtable.shouldSwitch(org.apache.cassandra.db.ColumnFamilyStore.FlushReason)(OWNED_RANGES_CHANGE) and, should that return false, a Memtable.localRangesUpdated() call.

Specified by:

localRangeSplits in interface Memtable.Owner

getOverlappingLiveSSTables
```
public java.util.Collection<SSTableReader> getOverlappingLiveSSTables(java.lang.Iterable<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.)

getAndReferenceOverlappingLiveSSTables

public Refs<SSTableReader> getAndReferenceOverlappingLiveSSTables(java.lang.Iterable<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 CompactionManager.AllSSTableOpStatus forceCleanup(int jobs)
                                                  throws java.util.concurrent.ExecutionException,
                                                         java.lang.InterruptedException

Throws:: java.util.concurrent.ExecutionException; java.lang.InterruptedException

scrub

public CompactionManager.AllSSTableOpStatus scrub(boolean disableSnapshot,
                                                  boolean skipCorrupted,
                                                  boolean checkData,
                                                  boolean reinsertOverflowedTTL,
                                                  int jobs)
                                           throws java.util.concurrent.ExecutionException,
                                                  java.lang.InterruptedException

Throws:: java.util.concurrent.ExecutionException; java.lang.InterruptedException

scrub

public CompactionManager.AllSSTableOpStatus scrub(boolean disableSnapshot,
                                                  boolean skipCorrupted,
                                                  boolean reinsertOverflowedTTL,
                                                  boolean alwaysFail,
                                                  boolean checkData,
                                                  int jobs)
                                           throws java.util.concurrent.ExecutionException,
                                                  java.lang.InterruptedException

Throws:: java.util.concurrent.ExecutionException; java.lang.InterruptedException

rebuildOnFailedScrub
```
public boolean rebuildOnFailedScrub(java.lang.Throwable failure)
```
CASSANDRA-5174 : For an index cfs we may be able to discard everything and just rebuild the index when a scrub fails.

Returns:

true if we are an index cfs and we successfully rebuilt the index

verify

public CompactionManager.AllSSTableOpStatus verify(Verifier.Options options)
                                            throws java.util.concurrent.ExecutionException,
                                                   java.lang.InterruptedException

Throws:: java.util.concurrent.ExecutionException; java.lang.InterruptedException

sstablesRewrite
```
public CompactionManager.AllSSTableOpStatus sstablesRewrite(boolean skipIfCurrentVersion,
                                                            long skipIfNewerThanTimestamp,
                                                            boolean skipIfCompressionMatches,
                                                            int jobs)
                                                     throws java.util.concurrent.ExecutionException,
                                                            java.lang.InterruptedException
```
Rewrites all SSTables according to specified parameters

Parameters:

skipIfCurrentVersion - - if true, will rewrite only SSTables that have version older than the current one (BigFormat#latestVersion)

skipIfNewerThanTimestamp - - max timestamp (local creation time) for SSTable; SSTables created _after_ this timestamp will be excluded from compaction

skipIfCompressionMatches - - if true, will rewrite only SSTables whose compression parameters are different from CFMetaData#compressionParams()

jobs - number of jobs for parallel execution

Throws:

java.util.concurrent.ExecutionException

java.lang.InterruptedException

relocateSSTables

public CompactionManager.AllSSTableOpStatus relocateSSTables(int jobs)
                                                      throws java.util.concurrent.ExecutionException,
                                                             java.lang.InterruptedException

Throws:: java.util.concurrent.ExecutionException; java.lang.InterruptedException

garbageCollect

public CompactionManager.AllSSTableOpStatus garbageCollect(CompactionParams.TombstoneOption tombstoneOption,
                                                           int jobs)
                                                    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)

isValid
```
public boolean isValid()
```

getTracker
```
public Tracker getTracker()
```
Package protected for access from the CompactionManager.

getLiveSSTables

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

getSSTables

public java.lang.Iterable<SSTableReader> getSSTables(SSTableSet sstableSet)

getUncompactingSSTables

public java.lang.Iterable<SSTableReader> getUncompactingSSTables()

getPendingRepairStats

public java.util.Map<TimeUUID,PendingStat> getPendingRepairStats()

releaseRepairData
```
public CleanupSummary releaseRepairData(java.util.Collection<TimeUUID> sessions,
                                        boolean force)
```
promotes (or demotes) data attached to an incremental repair session that has either completed successfully, or failed

Returns:

session ids whose data could not be released

isFilterFullyCoveredBy

public boolean isFilterFullyCoveredBy(ClusteringIndexFilter filter,
                                      DataLimits limits,
                                      CachedPartition cached,
                                      int nowInSec,
                                      boolean enforceStrictLiveness)

getPaxosRepairHistory

public PaxosRepairHistory getPaxosRepairHistory()

getPaxosRepairHistoryForRanges

public PaxosRepairHistory getPaxosRepairHistoryForRanges(java.util.Collection<Range<Token>> ranges)

syncPaxosRepairHistory

public void syncPaxosRepairHistory(PaxosRepairHistory sync,
                                   boolean flush)

onPaxosRepairComplete

public void onPaxosRepairComplete(java.util.Collection<Range<Token>> ranges,
                                  Ballot highBallot)

getPaxosRepairLowBound

public Ballot getPaxosRepairLowBound(DecoratedKey key)

gcBefore
```
public int gcBefore(int nowInSec)
```

selectAndReference

public ColumnFamilyStore.RefViewFragment selectAndReference(com.google.common.base.Function<View,java.lang.Iterable<SSTableReader>> filter)

select

public ColumnFamilyStore.ViewFragment select(com.google.common.base.Function<View,java.lang.Iterable<SSTableReader>> filter)

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

getSSTablesForKey
```
public java.util.List<java.lang.String> getSSTablesForKey(java.lang.String key,
                                                          boolean hexFormat)
```
Description copied from interface: ColumnFamilyStoreMBean

Returns a list of filenames that contain the given key on this node

Specified by:

getSSTablesForKey in interface ColumnFamilyStoreMBean

hexFormat - if key is in hex string format

Returns:

list of filenames containing the key

beginLocalSampling
```
public void beginLocalSampling(java.lang.String sampler,
                               int capacity,
                               int durationMillis)
```
Description copied from interface: ColumnFamilyStoreMBean

begin sampling for a specific sampler with a given capacity. The cardinality may be larger than the capacity, but depending on the use case it may affect its accuracy

Specified by:

beginLocalSampling in interface ColumnFamilyStoreMBean

finishLocalSampling

public java.util.List<javax.management.openmbean.CompositeData> finishLocalSampling(java.lang.String sampler,
                                                                                    int count)
                                                                             throws javax.management.openmbean.OpenDataException

Specified by:: finishLocalSampling in interface ColumnFamilyStoreMBean
Returns:: top count items for the sampler since beginLocalSampling was called
Throws:: javax.management.openmbean.OpenDataException

isCompactionDiskSpaceCheckEnabled
```
public boolean isCompactionDiskSpaceCheckEnabled()
```
Specified by:

isCompactionDiskSpaceCheckEnabled in interface ColumnFamilyStoreMBean

compactionDiskSpaceCheck
```
public void compactionDiskSpaceCheck(boolean enable)
```
Specified by:

compactionDiskSpaceCheck in interface ColumnFamilyStoreMBean

cleanupCache
```
public void cleanupCache()
```

getComparator

public ClusteringComparator getComparator()

snapshotWithoutMemtable

public TableSnapshot snapshotWithoutMemtable(java.lang.String snapshotName)

snapshotWithoutMemtable

public TableSnapshot snapshotWithoutMemtable(java.lang.String snapshotName,
                                             java.time.Instant creationTime)

snapshotWithoutMemtable

public TableSnapshot snapshotWithoutMemtable(java.lang.String snapshotName,
                                             com.google.common.base.Predicate<SSTableReader> predicate,
                                             boolean ephemeral,
                                             DurationSpec.IntSecondsBound ttl,
                                             com.google.common.util.concurrent.RateLimiter rateLimiter,
                                             java.time.Instant creationTime)

Parameters:: ephemeral - If this flag is set to true, the snapshot will be cleaned during next startup

createSnapshot

protected TableSnapshot createSnapshot(java.lang.String tag,
                                       boolean ephemeral,
                                       DurationSpec.IntSecondsBound ttl,
                                       java.util.Set<SSTableReader> sstables,
                                       java.time.Instant creationTime)

clearEphemeralSnapshots

protected static void clearEphemeralSnapshots(Directories directories)

getSnapshotSSTableReaders

public Refs<SSTableReader> getSnapshotSSTableReaders(java.lang.String tag)
                                              throws java.io.IOException

Throws:: java.io.IOException

snapshot
```
public TableSnapshot snapshot(java.lang.String snapshotName)
```
Take a snap shot of this columnfamily store.

Parameters:

snapshotName - the name of the associated with the snapshot

snapshot

public TableSnapshot snapshot(java.lang.String snapshotName,
                              DurationSpec.IntSecondsBound ttl)

snapshot
```
public TableSnapshot snapshot(java.lang.String snapshotName,
                              boolean skipMemtable,
                              DurationSpec.IntSecondsBound ttl,
                              com.google.common.util.concurrent.RateLimiter rateLimiter,
                              java.time.Instant creationTime)
```
Take a snap shot of this columnfamily store.

Parameters:

snapshotName - the name of the associated with the snapshot

skipMemtable - Skip flushing the memtable

ttl - duration after which the taken snapshot is removed automatically, if supplied with null, it will never be automatically removed

rateLimiter - Rate limiter for hardlinks-per-second

creationTime - time when this snapshot was taken

snapshot

public TableSnapshot snapshot(java.lang.String snapshotName,
                              com.google.common.base.Predicate<SSTableReader> predicate,
                              boolean ephemeral,
                              boolean skipMemtable)

Parameters:: ephemeral - If this flag is set to true, the snapshot will be cleaned up during next startup; skipMemtable - Skip flushing the memtable

snapshot

public TableSnapshot snapshot(java.lang.String snapshotName,
                              com.google.common.base.Predicate<SSTableReader> predicate,
                              boolean ephemeral,
                              boolean skipMemtable,
                              DurationSpec.IntSecondsBound ttl,
                              com.google.common.util.concurrent.RateLimiter rateLimiter,
                              java.time.Instant creationTime)

Parameters:: ephemeral - If this flag is set to true, the snapshot will be cleaned up during next startup; skipMemtable - Skip flushing the memtable; ttl - duration after which the taken snapshot is removed automatically, if supplied with null, it will never be automatically removed; rateLimiter - Rate limiter for hardlinks-per-second; creationTime - time when this snapshot was taken

snapshotExists

public boolean snapshotExists(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.

listSnapshots
```
public java.util.Map<java.lang.String,TableSnapshot> listSnapshots()
```
Returns:

Return a map of all snapshots to space being used The pair for a snapshot has true size and size on disk.

getRawCachedPartition
```
public CachedPartition getRawCachedPartition(DecoratedKey key)
```
Returns:

the cached partition for @param key if it is already present in the cache. Not that this will not readAndCache the parition if it is not present, nor are these calls counted in cache statistics. Note that this WILL cause deserialization of a SerializingCache partition, so if all you need to know is whether a partition is present or not, use containsCachedParition instead.

invalidateRowCache

public int invalidateRowCache(java.util.Collection<Bounds<Token>> boundsToInvalidate)

invalidateCounterCache

public int invalidateCounterCache(java.util.Collection<Bounds<Token>> boundsToInvalidate)

containsCachedParition
```
public boolean containsCachedParition(DecoratedKey key)
```
Returns:

true if @param key is contained in the row cache

invalidateCachedPartition

public void invalidateCachedPartition(RowCacheKey key)

invalidateCachedPartition

public void invalidateCachedPartition(DecoratedKey key)

getCachedCounter

public ClockAndCount getCachedCounter(java.nio.ByteBuffer partitionKey,
                                      Clustering<?> clustering,
                                      ColumnMetadata column,
                                      CellPath path)

putCachedCounter

public void putCachedCounter(java.nio.ByteBuffer partitionKey,
                             Clustering<?> clustering,
                             ColumnMetadata column,
                             CellPath path,
                             ClockAndCount clockAndCount)

forceMajorCompaction
```
public void forceMajorCompaction()
```

forceMajorCompaction
```
public void forceMajorCompaction(boolean splitOutput)
```
Description copied from interface: ColumnFamilyStoreMBean

force a major compaction of this column family

Specified by:

forceMajorCompaction in interface ColumnFamilyStoreMBean

Parameters:

splitOutput - true if the output of the major compaction should be split in several sstables

forceCompactionForTokenRange
```
public void forceCompactionForTokenRange(java.util.Collection<Range<Token>> tokenRanges)
                                  throws java.util.concurrent.ExecutionException,
                                         java.lang.InterruptedException
```
Description copied from interface: ColumnFamilyStoreMBean

Forces a major compaction of specified token ranges in this column family.
The token ranges will be interpreted as closed intervals to match the closed interval defined by the first and last keys of a sstable, even though the Range class is suppossed to be half-open by definition.

Specified by:

forceCompactionForTokenRange in interface ColumnFamilyStoreMBean

Parameters:

tokenRanges - The token ranges to be compacted, interpreted as closed intervals.

Throws:

java.util.concurrent.ExecutionException

java.lang.InterruptedException

forceCompactionForTokenRanges
```
public void forceCompactionForTokenRanges(java.lang.String... strings)
```
Description copied from interface: ColumnFamilyStoreMBean

Forces a major compaction of specified token ranges in this column family.
The token ranges will be interpreted as closed intervals to match the closed interval defined by the first and last keys of a sstable, even though the Range class is suppossed to be half-open by definition.

Specified by:

forceCompactionForTokenRanges in interface ColumnFamilyStoreMBean

forceCompactionForKey

public void forceCompactionForKey(DecoratedKey key)

all

public static java.lang.Iterable<ColumnFamilyStore> all()

keySamples

public java.lang.Iterable<DecoratedKey> keySamples(Range<Token> range)

estimatedKeysForRange

public long estimatedKeysForRange(Range<Token> range)

writeAndAddMemtableRanges

public void writeAndAddMemtableRanges(TimeUUID repairSessionID,
                                      java.util.function.Supplier<java.util.Collection<Range<PartitionPosition>>> rangesSupplier,
                                      Refs<SSTableReader> placeIntoRefs)

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()
```

truncateBlockingWithoutSnapshot

public void truncateBlockingWithoutSnapshot()

dumpMemtable
```
public Future<CommitLogPosition> dumpMemtable()
```
Drops current memtable without flushing to disk. This should only be called when truncating a column family that cannot have dirty intervals in the commit log (i.e. one which is not durable, or where the memtable itself performs durable writes).

unloadCf
```
public void unloadCf()
```

runWithCompactionsDisabled

public <V> V runWithCompactionsDisabled(java.util.concurrent.Callable<V> callable,
                                        boolean interruptValidation,
                                        boolean interruptViews)

runWithCompactionsDisabled
```
public <V> V runWithCompactionsDisabled(java.util.concurrent.Callable<V> callable,
                                        com.google.common.base.Predicate<SSTableReader> sstablesPredicate,
                                        boolean interruptValidation,
                                        boolean interruptViews,
                                        boolean interruptIndexes)
```
Runs callable with compactions paused and compactions including sstables matching sstablePredicate stopped

Parameters:

callable - what to do when compactions are paused

sstablesPredicate - which sstables should we cancel compactions for

interruptValidation - if we should interrupt validation compactions

interruptViews - if we should interrupt view compactions

interruptIndexes - if we should interrupt compactions on indexes. NOTE: if you set this to true your sstablePredicate must be able to handle LocalPartitioner sstables!

markAllCompacting

public LifecycleTransaction markAllCompacting(OperationType operationType)

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

getCompactionStrategyManager

public CompactionStrategyManager getCompactionStrategyManager()

setCrcCheckChance
```
public void setCrcCheckChance(double crcCheckChance)
```
Description copied from interface: ColumnFamilyStoreMBean

Set new crc check chance

Specified by:

setCrcCheckChance in interface ColumnFamilyStoreMBean

getCrcCheckChance

public java.lang.Double getCrcCheckChance()

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

getMeanEstimatedCellPerPartitionCount

public int getMeanEstimatedCellPerPartitionCount()

getMeanPartitionSize
```
public double getMeanPartitionSize()
```

getMeanRowCount
```
public int getMeanRowCount()
```

estimateKeys
```
public long estimateKeys()
```
Specified by:

estimateKeys in interface ColumnFamilyStoreMBean

getPartitioner
```
public IPartitioner getPartitioner()
```

decorateKey

public DecoratedKey decorateKey(java.nio.ByteBuffer key)

isIndex
```
public boolean isIndex()
```
true if this CFS contains secondary index data

concatWithIndexes

public java.lang.Iterable<ColumnFamilyStore> concatWithIndexes()

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

getPerLevelSizeBytes
```
public long[] getPerLevelSizeBytes()
```
Specified by:

getPerLevelSizeBytes in interface ColumnFamilyStoreMBean

Returns:

total size on disk for each level. null unless leveled compaction is used. array index corresponds to level(int[0] is for level 0, ...).

getLevelFanoutSize
```
public int getLevelFanoutSize()
```
Specified by:

getLevelFanoutSize in interface ColumnFamilyStoreMBean

Returns:

sstable fanout size for level compaction strategy.

isEmpty
```
public boolean isEmpty()
```

isRowCacheEnabled
```
public boolean isRowCacheEnabled()
```

isCounterCacheEnabled

public boolean isCounterCacheEnabled()

isKeyCacheEnabled
```
public boolean isKeyCacheEnabled()
```

discardSSTables
```
public void 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)

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

trueSnapshotsSize
```
public long trueSnapshotsSize()
```
Specified by:

trueSnapshotsSize in interface ColumnFamilyStoreMBean

Returns:

the size of SSTables in "snapshots" subdirectory which aren't live anymore

getIfExists
```
public static ColumnFamilyStore getIfExists(TableId id)
```
Returns a ColumnFamilyStore by id if it exists, null otherwise Differently from others, this method does not throw exception if the table does not exist.

getIfExists
```
public static ColumnFamilyStore getIfExists(java.lang.String ksName,
                                            java.lang.String cfName)
```
Returns a ColumnFamilyStore by ksname and cfname if it exists, null otherwise Differently from others, this method does not throw exception if the keyspace or table does not exist.

metricsFor

public static TableMetrics metricsFor(TableId tableId)

getDiskBoundaries

public DiskBoundaries getDiskBoundaries()

invalidateLocalRanges
```
public void invalidateLocalRanges()
```

setNeverPurgeTombstones
```
public void setNeverPurgeTombstones(boolean value)
```
Specified by:

setNeverPurgeTombstones in interface ColumnFamilyStoreMBean

getNeverPurgeTombstones
```
public boolean getNeverPurgeTombstones()
```
Specified by:

getNeverPurgeTombstones in interface ColumnFamilyStoreMBean

hasMisplacedSSTables
```
public boolean hasMisplacedSSTables()
```
Description copied from interface: ColumnFamilyStoreMBean

Check SSTables whether or not they are misplaced.

Specified by:

hasMisplacedSSTables in interface ColumnFamilyStoreMBean

Returns:

true if any of the SSTables is misplaced. If all SSTables are correctly placed or the partitioner does not support splitting, it returns false.

getTopSizePartitions
```
public java.util.Map<java.lang.String,java.lang.Long> getTopSizePartitions()
```
Specified by:

getTopSizePartitions in interface ColumnFamilyStoreMBean

getTopSizePartitionsLastUpdate
```
public java.lang.Long getTopSizePartitionsLastUpdate()
```
Specified by:

getTopSizePartitionsLastUpdate in interface ColumnFamilyStoreMBean

getTopTombstonePartitions
```
public java.util.Map<java.lang.String,java.lang.Long> getTopTombstonePartitions()
```
Specified by:

getTopTombstonePartitions in interface ColumnFamilyStoreMBean

getTopTombstonePartitionsLastUpdate
```
public java.lang.Long getTopTombstonePartitionsLastUpdate()
```
Specified by:

getTopTombstonePartitionsLastUpdate in interface ColumnFamilyStoreMBean

Class ColumnFamilyStore

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

SNAPSHOT_TRUNCATE_PREFIX

SNAPSHOT_DROP_PREFIX

keyspace

name

metadata

readOrdering

indexManager

viewManager

metric

sampleReadLatencyMicros

additionalWriteLatencyMicros

topPartitions

Constructor Detail

ColumnFamilyStore

Method Detail

shutdownPostFlushExecutor

shutdownExecutorsAndWait

reload

getBackgroundCompactionTaskSubmitter

getCompactionParameters

getCompactionParametersJson

setCompactionParameters

setCompactionParametersJson

getCompressionParameters

getCompressionParametersJson

setCompressionParameters

setCompressionParametersJson

getTableMBeanName

getColumnFamilieMBeanName

updateSpeculationThreshold

getWriteHandler

getStreamManager

getRepairManager

metadata

getDirectories

getDataPaths

writesShouldSkipCommitLog

memtableWritesAreDurable

streamToMemtable

streamFromMemtable

createSSTableMultiWriter

createSSTableMultiWriter

supportsEarlyOpen

invalidate

invalidate

invalidate

createColumnFamilyStore

createColumnFamilyStore

createColumnFamilyStore

scrubDataDirectories

loadNewSSTables

loadNewSSTables

importNewSSTables

importNewSSTables

rebuildSecondaryIndex

rebuildSecondaryIndex

createCompactionStrategyInstance

getColumnFamilyName

getTableName

newSSTableDescriptor

newSSTableDescriptor

newSSTableDescriptor

switchMemtableIfCurrent

switchMemtable

forceFlush

forceFlush

forceBlockingFlush

createMemtable

signalFlushRequired

getCurrentMemtable

activeMemtables

getIndexMemtables

apply