Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.apache.cassandra.db.compaction
Class LeveledCompactionStrategy

    java.lang.Object
      org.apache.cassandra.db.compaction.AbstractCompactionStrategy
          org.apache.cassandra.db.compaction.LeveledCompactionStrategy

All Implemented Interfaces:
  INotificationConsumer

    public class LeveledCompactionStrategy

extends AbstractCompactionStrategy
implements INotificationConsumer

Field Summary

Fields inherited from class org.apache.cassandra.db.compaction.AbstractCompactionStrategy
`cfs, options`

Constructor Summary
`LeveledCompactionStrategy(ColumnFamilyStore cfs, java.util.Map<java.lang.String,java.lang.String> options)`

Method Summary
`int` | `getEstimatedRemainingTasks()`
`int` | `getLevelSize(int i)`
`AbstractCompactionTask` | `getMaximalTask(int gcBefore)`
`long` | `getMaxSSTableSize()`
`AbstractCompactionTask` | `getNextBackgroundTask(int gcBefore)` the only difference between background and maximal in LCS is that maximal is still allowed (by explicit user request) even when compaction is disabled.
`java.util.List<ICompactionScanner>` | `getScanners(java.util.Collection<SSTableReader> sstables, Range<Token> range)` Returns a list of KeyScanners given sstables and a range on which to scan.
`AbstractCompactionTask` | `getUserDefinedTask(java.util.Collection<SSTableReader> sstables, int gcBefore)`
`void` | `handleNotification(INotification notification, java.lang.Object sender)`
`boolean` | `isKeyExistenceExpensive(java.util.Set<? extends SSTable> sstablesToIgnore)`
`void` | `shutdown()` Releases any resources if this strategy is shutdown (when the CFS is reloaded after a schema change).
`java.lang.String` | `toString()`

Methods inherited from class org.apache.cassandra.db.compaction.AbstractCompactionStrategy
`filterSuspectSSTables, getOptions, getScanners`

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

Constructor Detail

### LeveledCompactionStrategy

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

Method Detail

### shutdown

    public void shutdown()

  Description copied from class: `AbstractCompactionStrategy`
  Releases any resources if this strategy is shutdown (when the CFS is reloaded after a schema change). Default is to do nothing.

  Overrides:
    `shutdown` in class `AbstractCompactionStrategy`

### getLevelSize

    public int getLevelSize(int i)

### getNextBackgroundTask

    public AbstractCompactionTask getNextBackgroundTask(int gcBefore)

  the only difference between background and maximal in LCS is that maximal is still allowed (by explicit user request) even when compaction is disabled.

  Specified by:
    `getNextBackgroundTask` in class `AbstractCompactionStrategy`
  Parameters:
    `gcBefore` - throw away tombstones older than this
  Returns:
    the next background/minor compaction task to run; null if nothing to do.

### getMaximalTask

    public AbstractCompactionTask getMaximalTask(int gcBefore)

  Specified by:
    `getMaximalTask` in class `AbstractCompactionStrategy`
  Parameters:
    `gcBefore` - throw away tombstones older than this
  Returns:
    a compaction task that should be run to compact this columnfamilystore as much as possible. Null if nothing to do.

### getUserDefinedTask

    public AbstractCompactionTask getUserDefinedTask(java.util.Collection<SSTableReader> sstables,
                                                     int gcBefore)

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

### getEstimatedRemainingTasks

    public int getEstimatedRemainingTasks()

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

### handleNotification

    public void handleNotification(INotification notification,
                                   java.lang.Object sender)

  Specified by:
    `handleNotification` in interface `INotificationConsumer`

### getMaxSSTableSize

    public long getMaxSSTableSize()

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

### isKeyExistenceExpensive

    public boolean isKeyExistenceExpensive(java.util.Set<? extends SSTable> sstablesToIgnore)

  Specified by:
    `isKeyExistenceExpensive` in class `AbstractCompactionStrategy`
  Returns:
    true if checking for whether a key exists, ignoring @param sstablesToIgnore, is going to be expensive

### getScanners

    public java.util.List<ICompactionScanner> getScanners(java.util.Collection<SSTableReader> sstables,
                                                          Range<Token> range)
                                                   throws java.io.IOException

  Description copied from class: `AbstractCompactionStrategy`
  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).

  Overrides:
    `getScanners` in class `AbstractCompactionStrategy`
  Throws:
    `java.io.IOException`

### toString

    public java.lang.String toString()

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

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2013 The Apache Software Foundation