Package org.apache.cassandra.db.compaction

Class AbstractCompactionStrategy

    • Field Detail

      • DEFAULT_TOMBSTONE_THRESHOLD

        protected static final float DEFAULT_TOMBSTONE_THRESHOLD
        See Also:
        Constant Field Values

      • DEFAULT_TOMBSTONE_COMPACTION_INTERVAL

        protected static final long DEFAULT_TOMBSTONE_COMPACTION_INTERVAL
        See Also:
        Constant Field Values

      • DEFAULT_UNCHECKED_TOMBSTONE_COMPACTION_OPTION

        protected static final boolean DEFAULT_UNCHECKED_TOMBSTONE_COMPACTION_OPTION
        See Also:
        Constant Field Values

      • DEFAULT_LOG_ALL_OPTION

        protected static final boolean DEFAULT_LOG_ALL_OPTION
        See Also:
        Constant Field Values

      • TOMBSTONE_THRESHOLD_OPTION

        protected static final java.lang.String TOMBSTONE_THRESHOLD_OPTION
        See Also:
        Constant Field Values

      • TOMBSTONE_COMPACTION_INTERVAL_OPTION

        protected static final java.lang.String TOMBSTONE_COMPACTION_INTERVAL_OPTION
        See Also:
        Constant Field Values

      • UNCHECKED_TOMBSTONE_COMPACTION_OPTION

        protected static final java.lang.String UNCHECKED_TOMBSTONE_COMPACTION_OPTION
        See Also:
        Constant Field Values

      • COMPACTION_ENABLED

        protected static final java.lang.String COMPACTION_ENABLED
        See Also:
        Constant Field Values

      • ONLY_PURGE_REPAIRED_TOMBSTONES

        public static final java.lang.String ONLY_PURGE_REPAIRED_TOMBSTONES
        See Also:
        Constant Field Values

      • options

        protected java.util.Map<java.lang.String,​java.lang.String> options

      • tombstoneThreshold

        protected float tombstoneThreshold

      • tombstoneCompactionInterval

        protected long tombstoneCompactionInterval

      • uncheckedTombstoneCompaction

        protected boolean uncheckedTombstoneCompaction

      • disableTombstoneCompactions

        protected boolean disableTombstoneCompactions

      • logAll

        protected boolean logAll

      • isActive

        protected boolean isActive
        pause/resume/getNextBackgroundTask must synchronize. This guarantees that after pause completes, no new tasks will be generated; or put another way, pause can't run until in-progress tasks are done being created. This allows runWithCompactionsDisabled to be confident that after pausing, once in-progress tasks abort, it's safe to proceed with truncate/cleanup/etc. See CASSANDRA-3430

    • Constructor Detail

      • AbstractCompactionStrategy

        protected AbstractCompactionStrategy​(ColumnFamilyStore cfs,
                                     java.util.Map<java.lang.String,​java.lang.String> options)

    • Method Detail

      • pause

        public void pause()
        For internal, temporary suspension of background compactions so that we can do exceptional things like truncate or major compaction

      • resume

        public void resume()
        For internal, temporary suspension of background compactions so that we can do exceptional things like truncate or major compaction

      • startup

        public void startup()
        Performs any extra initialization required

      • shutdown

        public void shutdown()
        Releases any resources if this strategy is shutdown (when the CFS is reloaded after a schema change).

      • getNextBackgroundTask

        public abstract AbstractCompactionTask getNextBackgroundTask​(long gcBefore)
        Parameters:
        gcBefore - throw away tombstones older than this
        Returns:
        the next background/minor compaction task to run; null if nothing to do. Is responsible for marking its sstables as compaction-pending.

      • getMaximalTask

        public abstract java.util.Collection<AbstractCompactionTask> getMaximalTask​(long gcBefore,
                                                                            boolean splitOutput)
        Parameters:
        gcBefore - throw away tombstones older than this
        Returns:
        a compaction task that should be run to compact this columnfamilystore as much as possible. Null if nothing to do. Is responsible for marking its sstables as compaction-pending.

      • getUserDefinedTask

        public abstract AbstractCompactionTask getUserDefinedTask​(java.util.Collection<SSTableReader> sstables,
                                                          long gcBefore)
        Parameters:
        sstables - SSTables to compact. Must be marked as compacting.
        gcBefore - throw away tombstones older than this
        Returns:
        a compaction task corresponding to the requested sstables. Will not be null. (Will throw if user requests an invalid compaction.) Is responsible for marking its sstables as compaction-pending.

      • getEstimatedRemainingTasks

        public abstract int getEstimatedRemainingTasks()
        Returns:
        the number of background tasks estimated to still be needed for this columnfamilystore

      • getMaxSSTableBytes

        public abstract long getMaxSSTableBytes()
        Returns:
        size in bytes of the largest sstables for this strategy

      • filterSuspectSSTables

        public static java.util.List<SSTableReader> filterSuspectSSTables​(java.lang.Iterable<SSTableReader> originalCandidates)
        Filters SSTables that are to be excluded from the given collection
        Parameters:
        originalCandidates - The collection to check for excluded SSTables
        Returns:
        list of the SSTables with excluded ones filtered out

      • getScanners

        public AbstractCompactionStrategy.ScannerList getScanners​(java.util.Collection<SSTableReader> sstables,
                                                          java.util.Collection<Range<Token>> ranges)
        Returns a list of KeyScanners given sstables and a range on which to scan. The default implementation simply grab one SSTableScanner per-sstable, but overriding this method allow for a more memory efficient solution if we know the sstable don't overlap (see LeveledCompactionStrategy for instance).

      • getName

        public java.lang.String getName()

      • replaceSSTables

        public void replaceSSTables​(java.util.Collection<SSTableReader> removed,
                            java.util.Collection<SSTableReader> added)
        Replaces sstables in the compaction strategy Note that implementations must be able to handle duplicate notifications here (that removed are already gone and added have already been added)

      • addSSTable

        public abstract void addSSTable​(SSTableReader added)
        Adds sstable, note that implementations must handle duplicate notifications here (added already being in the compaction strategy)

      • addSSTables

        public void addSSTables​(java.lang.Iterable<SSTableReader> added)
        Adds sstables, note that implementations must handle duplicate notifications here (added already being in the compaction strategy)

      • removeSSTable

        public abstract void removeSSTable​(SSTableReader sstable)
        Removes sstable from the strategy, implementations must be able to handle the sstable having already been removed.

      • removeSSTables

        public void removeSSTables​(java.lang.Iterable<SSTableReader> removed)
        Removes sstables from the strategy, implementations must be able to handle the sstables having already been removed.

      • getSSTables

        protected abstract java.util.Set<SSTableReader> getSSTables()
        Returns the sstables managed by this strategy instance

      • metadataChanged

        public void metadataChanged​(StatsMetadata oldMetadata,
                            SSTableReader sstable)
        Called when the metadata has changed for an sstable - for example if the level changed Not called when repair status changes (which is also metadata), because this results in the sstable getting removed from the compaction strategy instance.

      • worthDroppingTombstones

        protected boolean worthDroppingTombstones​(SSTableReader sstable,
                                          long gcBefore)
        Check if given sstable is worth dropping tombstones at gcBefore. Check is skipped if tombstone_compaction_interval time does not elapse since sstable creation and returns false.
        Parameters:
        sstable - SSTable to check
        gcBefore - time to drop tombstones
        Returns:
        true if given sstable's tombstones are expected to be removed

      • validateOptions

        public static java.util.Map<java.lang.String,​java.lang.String> validateOptions​(java.util.Map<java.lang.String,​java.lang.String> options)
                                                                              throws ConfigurationException
        Throws:
        ConfigurationException

      • groupSSTablesForAntiCompaction

        public java.util.Collection<java.util.Collection<SSTableReader>> groupSSTablesForAntiCompaction​(java.util.Collection<SSTableReader> sstablesToGroup)
        Method for grouping similar SSTables together, This will be used by anti-compaction to determine which SSTables should be anitcompacted as a group. If a given compaction strategy creates sstables which cannot be merged due to some constraint it must override this method.

      • supportsEarlyOpen

        public boolean supportsEarlyOpen()