org.apache.cassandra.db

## Class ColumnFamilyStore

- 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.FlushLargestColumnFamily` Finds the largest memtable, as a percentage of *either* on- or off-heap memory limits, and immediately queues it for flushing.
    `static class` | `ColumnFamilyStore.RefViewFragment`
    `static class` | `ColumnFamilyStore.ViewFragment`

  - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `SecondaryIndexManager` | `indexManager`
    `Keyspace` | `keyspace`
    `CFMetaData` | `metadata`
    `TableMetrics` | `metric`
    `java.lang.String` | `name`
    `OpOrder` | `readOrdering`
    `long` | `sampleLatencyNanos`
    `static java.lang.String` | `SNAPSHOT_DROP_PREFIX`
    `static java.lang.String` | `SNAPSHOT_TRUNCATE_PREFIX`
    `TableViews` | `viewManager`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `ColumnFamilyStore(Keyspace keyspace, java.lang.String columnFamilyName, int generation, CFMetaData 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 void` | `addInitialDirectories(Directories.DataDirectory[] newDirectories)` A hook to add additional directories to initialDirectories.
    `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)` 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, CFMetaData metadata, boolean loadSSTables)`
    `static ColumnFamilyStore` | `createColumnFamilyStore(Keyspace keyspace, java.lang.String columnFamily, CFMetaData metadata, boolean loadSSTables)`
    `static ColumnFamilyStore` | `createColumnFamilyStore(Keyspace keyspace, java.lang.String columnFamily, CFMetaData metadata, Directories directories, boolean loadSSTables, boolean registerBookkeeping, boolean offline)` This is only directly used by offline tools
    `SSTableMultiWriter` | `createSSTableMultiWriter(Descriptor descriptor, long keyCount, long repairedAt, int sstableLevel, SerializationHeader header, LifecycleTransaction txn)`
    `SSTableMultiWriter` | `createSSTableMultiWriter(Descriptor descriptor, long keyCount, long repairedAt, MetadataCollector metadataCollector, SerializationHeader header, LifecycleTransaction txn)`
    `DecoratedKey` | `decorateKey(java.nio.ByteBuffer key)`
    `void` | `disableAutoCompaction()`
    `void` | `discardSSTables(long truncatedAt)` Discard all SSTables that were created before given timestamp.
    `java.util.concurrent.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()`
    `javax.management.openmbean.CompositeData` | `finishLocalSampling(java.lang.String sampler, int count)`
    `CommitLogPosition` | `forceBlockingFlush()`
    `CompactionManager.AllSSTableOpStatus` | `forceCleanup(int jobs)`
    `void` | `forceCompactionForTokenRange(java.util.Collection<Range<Token>> tokenRanges)` force a major compaction of specified key range in this column family
    `com.google.common.util.concurrent.ListenableFuture<CommitLogPosition>` | `forceFlush()` Flush if there is unflushed data in the memtables
    `com.google.common.util.concurrent.ListenableFuture<?>` | `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, ColumnDefinition column, CellPath path)`
    `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.Double` | `getCrcCheckChance()`
    `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(java.util.UUID cfId)` Returns a ColumnFamilyStore by cfId if it exists, null otherwise Differently from others, this method does not throw exception if the table does not exist.
    `static Directories.DataDirectory[]` | `getInitialDirectories()`
    `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` | `getMeanColumns()`
    `double` | `getMeanPartitionSize()`
    `int` | `getMinimumCompactionThreshold()` Gets the minimum number of sstables in queue before compaction kicks off
    `java.util.Collection<SSTableReader>` | `getOverlappingLiveSSTables(java.lang.Iterable<SSTableReader> sstables)`
    `IPartitioner` | `getPartitioner()`
    `CachedPartition` | `getRawCachedPartition(DecoratedKey key)`
    `long` | `getSnapshotCreationTime(java.lang.String snapshotName)`
    `java.util.Map<java.lang.String,Pair<java.lang.Long,java.lang.Long>>` | `getSnapshotDetails()`
    `Refs<SSTableReader>` | `getSnapshotSSTableReader(java.lang.String tag)`
    `int[]` | `getSSTableCountPerLevel()`
    `java.lang.String` | `getSSTablePath(java.io.File directory)`
    `java.lang.String` | `getSSTablePath(java.io.File directory, SSTableFormat.Type format)`
    `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
    `java.lang.String` | `getTableName()`
    `Tracker` | `getTracker()` Package protected for access from the CompactionManager.
    `java.lang.Iterable<SSTableReader>` | `getUncompactingSSTables()`
    `int` | `getUnleveledSSTables()`
    `void` | `invalidate()` call when dropping or renaming a CF.
    `void` | `invalidate(boolean expectMBean)`
    `void` | `invalidateCachedPartition(DecoratedKey key)`
    `void` | `invalidateCachedPartition(RowCacheKey key)`
    `int` | `invalidateCounterCache(java.util.Collection<Bounds<Token>> boundsToInvalidate)`
    `void` | `invalidateDiskBoundaries()`
    `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` | `isIndex()` true if this CFS contains secondary index data
    `boolean` | `isKeyCacheEnabled()`
    `boolean` | `isRowCacheEnabled()`
    `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
    `LifecycleTransaction` | `markAllCompacting(OperationType operationType)`
    `void` | `markObsolete(java.util.Collection<SSTableReader> sstables, OperationType compactionType)`
    `static TableMetrics` | `metricsFor(java.util.UUID tableId)`
    `void` | `putCachedCounter(java.nio.ByteBuffer partitionKey, Clustering clustering, ColumnDefinition 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)`
    `void` | `reload()`
    `CompactionManager.AllSSTableOpStatus` | `relocateSSTables(int jobs)`
    `<V> V` | `runWithCompactionsDisabled(java.util.concurrent.Callable<V> callable, boolean interruptValidation, boolean interruptViews)`
    `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(CFMetaData 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
    `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
    `static void` | `shutdownPostFlushExecutor()`
    `java.util.Set<SSTableReader>` | `snapshot(java.lang.String snapshotName)` Take a snap shot of this columnfamily store.
    `java.util.Set<SSTableReader>` | `snapshot(java.lang.String snapshotName, boolean skipFlush)` Take a snap shot of this columnfamily store.
    `java.util.Set<SSTableReader>` | `snapshot(java.lang.String snapshotName, com.google.common.base.Predicate<SSTableReader> predicate, boolean ephemeral, boolean skipFlush)`
    `boolean` | `snapshotExists(java.lang.String snapshotName)`
    `void` | `snapshotWithoutFlush(java.lang.String snapshotName)`
    `java.util.Set<SSTableReader>` | `snapshotWithoutFlush(java.lang.String snapshotName, com.google.common.base.Predicate<SSTableReader> predicate, boolean ephemeral)`
    `CompactionManager.AllSSTableOpStatus` | `sstablesRewrite(boolean excludeCurrentVersion, int jobs)`
    `boolean` | `supportsEarlyOpen()`
    `com.google.common.util.concurrent.ListenableFuture<CommitLogPosition>` | `switchMemtable()`
    `com.google.common.util.concurrent.ListenableFuture<CommitLogPosition>` | `switchMemtableIfCurrent(Memtable memtable)` Switches the memtable iff the live memtable is the one provided
    `java.lang.String` | `toString()`
    `long` | `trueSnapshotsSize()`
    `void` | `truncateBlocking()` Truncate deletes the entire column family's data with no expensive tombstone creation
    `CompactionManager.AllSSTableOpStatus` | `verify(boolean extendedVerify)`

    - ### 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 CFMetaData metadata

    - #### readOrdering

          public final OpOrder readOrdering

    - #### indexManager

          public final SecondaryIndexManager indexManager

    - #### viewManager

          public final TableViews viewManager

    - #### metric

          public final TableMetrics metric

    - #### sampleLatencyNanos

          public volatile long sampleLatencyNanos

  - ### Constructor Detail

    - #### ColumnFamilyStore

          public ColumnFamilyStore(Keyspace keyspace,
                                   java.lang.String columnFamilyName,
                                   int generation,
                                   CFMetaData metadata,
                                   Directories directories,
                                   boolean loadSSTables,
                                   boolean registerBookeeping,
                                   boolean offline)

  - ### Method Detail

    - #### addInitialDirectories

          public static void addInitialDirectories(Directories.DataDirectory[] newDirectories)

      A hook to add additional directories to initialDirectories. Any additional directories should be added prior to ColumnFamilyStore instantiation on startup Since the directories used by a given table are determined by the compaction strategy, it's possible for sstables to be written to directories specified outside of cassandra.yaml. By adding additional directories to initialDirectories, sstables in these extra locations are made discoverable on sstable instantiation.

    - #### getInitialDirectories

          public static Directories.DataDirectory[] getInitialDirectories()

    - #### shutdownPostFlushExecutor

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

      Throws:
        `java.lang.InterruptedException`

    - #### reload

          public void reload()

    - #### getBackgroundCompactionTaskSubmitter

          public static java.lang.Runnable getBackgroundCompactionTaskSubmitter()

    - #### 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 = {..}

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

    - #### getCompactionParameters

          public java.util.Map<java.lang.String,java.lang.String> getCompactionParameters()

      Specified by:
        `getCompactionParameters` 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

    - #### getDirectories

          public Directories getDirectories()

    - #### createSSTableMultiWriter

          public SSTableMultiWriter createSSTableMultiWriter(Descriptor descriptor,
                                                             long keyCount,
                                                             long repairedAt,
                                                             int sstableLevel,
                                                             SerializationHeader header,
                                                             LifecycleTransaction txn)

    - #### createSSTableMultiWriter

          public SSTableMultiWriter createSSTableMultiWriter(Descriptor descriptor,
                                                             long keyCount,
                                                             long repairedAt,
                                                             MetadataCollector metadataCollector,
                                                             SerializationHeader header,
                                                             LifecycleTransaction txn)

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

    - #### createColumnFamilyStore

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

    - #### createColumnFamilyStore

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

    - #### createColumnFamilyStore

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

      This is only directly used by offline tools

    - #### scrubDataDirectories

          public static void scrubDataDirectories(CFMetaData 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.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 void rebuildSecondaryIndex(java.lang.String idxName)

    - #### rebuildSecondaryIndex

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

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

    - #### getSSTablePath

          public java.lang.String getSSTablePath(java.io.File directory)

    - #### getSSTablePath

          public java.lang.String getSSTablePath(java.io.File directory,
                                                 SSTableFormat.Type format)

    - #### switchMemtableIfCurrent

          public com.google.common.util.concurrent.ListenableFuture<CommitLogPosition> switchMemtableIfCurrent(Memtable memtable)

      Switches the memtable iff the live memtable is the one provided
      Parameters:
        `memtable` -

    - #### switchMemtable

          public com.google.common.util.concurrent.ListenableFuture<CommitLogPosition> switchMemtable()

    - #### forceFlush

          public com.google.common.util.concurrent.ListenableFuture<CommitLogPosition> forceFlush()

      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 com.google.common.util.concurrent.ListenableFuture<?> 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()

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

    - #### 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(boolean extendedVerify)
                                                      throws java.util.concurrent.ExecutionException,
                                                             java.lang.InterruptedException

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

    - #### sstablesRewrite

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

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

    - #### isFilterFullyCoveredBy

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

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

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

    - #### snapshotWithoutFlush

          public void snapshotWithoutFlush(java.lang.String snapshotName)

    - #### snapshotWithoutFlush

          public java.util.Set<SSTableReader> snapshotWithoutFlush(java.lang.String snapshotName,
                                                                   com.google.common.base.Predicate<SSTableReader> predicate,
                                                                   boolean ephemeral)

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

    - #### clearEphemeralSnapshots

          protected static void clearEphemeralSnapshots(Directories directories)

    - #### getSnapshotSSTableReader

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

      Throws:
        `java.io.IOException`

    - #### snapshot

          public java.util.Set<SSTableReader> 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 java.util.Set<SSTableReader> snapshot(java.lang.String snapshotName,
                                                       boolean skipFlush)

      Take a snap shot of this columnfamily store.
      Parameters:
        `snapshotName` - the name of the associated with the snapshot
        `skipFlush` - Skip blocking flush of memtable

    - #### snapshot

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

      Parameters:
        `ephemeral` - If this flag is set to true, the snapshot will be cleaned up during next startup
        `skipFlush` - Skip blocking flush of memtable

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

    - #### getSnapshotDetails

          public java.util.Map<java.lang.String,Pair<java.lang.Long,java.lang.Long>> getSnapshotDetails()

      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,
                                                ColumnDefinition column,
                                                CellPath path)

    - #### putCachedCounter

          public void putCachedCounter(java.nio.ByteBuffer partitionKey,
                                       Clustering clustering,
                                       ColumnDefinition column,
                                       CellPath path,
                                       ClockAndCount clockAndCount)

    - #### forceMajorCompaction

          public void forceMajorCompaction()
                                    throws java.lang.InterruptedException,
                                           java.util.concurrent.ExecutionException

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

    - #### forceMajorCompaction

          public void forceMajorCompaction(boolean splitOutput)
                                    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`
      Parameters:
        `splitOutput` - true if the output of the major compaction should be split in several sstables
      Throws:
        `java.lang.InterruptedException`
        `java.util.concurrent.ExecutionException`

    - #### forceCompactionForTokenRange

          public void forceCompactionForTokenRange(java.util.Collection<Range<Token>> tokenRanges)
                                            throws java.util.concurrent.ExecutionException,
                                                   java.lang.InterruptedException

      Description copied from interface: `ColumnFamilyStoreMBean`
      force a major compaction of specified key range in this column family
      Specified by:
        `forceCompactionForTokenRange` in interface `ColumnFamilyStoreMBean`
      Throws:
        `java.util.concurrent.ExecutionException`
        `java.lang.InterruptedException`

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

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

    - #### dumpMemtable

          public java.util.concurrent.Future<CommitLogPosition> dumpMemtable()

      Drops current memtable without flushing to disk. This should only be called when truncating a column family which is not durable.

    - #### runWithCompactionsDisabled

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

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

    - #### getMeanColumns

          public int getMeanColumns()

    - #### getMeanPartitionSize

          public double getMeanPartitionSize()

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

    - #### 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(java.util.UUID cfId)

      Returns a ColumnFamilyStore by cfId 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(java.util.UUID tableId)

    - #### getDiskBoundaries

          public DiskBoundaries getDiskBoundaries()

    - #### invalidateDiskBoundaries

          public void invalidateDiskBoundaries()

Copyright © 2018 The Apache Software Foundation