SecondaryIndexManager (apache-cassandra API)

java.lang.Object
- org.apache.cassandra.index.SecondaryIndexManager

All Implemented Interfaces:

IndexRegistry
```
public class SecondaryIndexManager
extends java.lang.Object
implements IndexRegistry
```
Handles the core maintenance functionality associated with indexes: adding/removing them to or from a table, (re)building during bootstrap or other streaming operations, flushing, reloading metadata and so on. The Index interface defines a number of methods which return Callable. These are primarily the management tasks for an index implementation. Most of them are currently executed in a blocking fashion via submission to SIM's blockingExecutor. This provides the desired behaviour in pretty much all cases, as tasks like flushing an index needs to be executed synchronously to avoid potentially deadlocking on the FlushWriter or PostFlusher. Several of these Callable returning methods on Index could then be defined with as void and called directly from SIM (rather than being run via the executor service). Separating the task defintion from execution gives us greater flexibility though, so that in future, for example, if the flush process allows it we leave open the possibility of executing more of these tasks asynchronously. The primary exception to the above is the Callable returned from Index#addIndexedColumn. This may involve a significant effort, building a new index over any existing data. We perform this task asynchronously; as it is called as part of a schema update, which we do not want to block for a long period. Building non-custom indexes is performed on the CompactionManager. This class also provides instances of processors which listen to updates to the base table and forward to registered Indexes the info required to keep those indexes up to date. There are two variants of these processors, each with a factory method provided by SIM: IndexTransaction: deals with updates generated on the regular write path. CleanupTransaction: used when partitions are modified during compaction or cleanup operations. Further details on their usage and lifecycles can be found in the interface definitions below. Finally, the bestIndexFor method is used at query time to identify the most selective index of those able to satisfy any search predicates defined by a ReadCommand's RowFilter. It returns a thin IndexAccessor object which enables the ReadCommand to access the appropriate functions of the Index at various stages in its lifecycle. e.g. the getEstimatedResultRows is required when StorageProxy calculates the initial concurrency factor for distributing requests to replicas, whereas a Searcher instance is needed when the ReadCommand is executed locally on a target replica.

Field Summary

Fields
Modifier and Type Field and Description

ColumnFamilyStore baseCfs
The underlying column family containing the source data for these indexes

Fields
Modifier and Type	Field and Description
`ColumnFamilyStore`	`baseCfs` The underlying column family containing the source data for these indexes

Constructor Summary

Constructors
Constructor and Description

SecondaryIndexManager(ColumnFamilyStore baseCfs)

Constructors
Constructor and Description
`SecondaryIndexManager(ColumnFamilyStore baseCfs)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`java.util.concurrent.Future<?>`	`addIndex(IndexMetadata indexDef)` Adds and builds a index
`void`	`buildAllIndexesBlocking(java.util.Collection<SSTableReader> sstables)`
`void`	`buildIndexBlocking(Index index)`
`void`	`deletePartition(UnfilteredRowIterator partition, int nowInSec)` Delete all data from all indexes for this partition.
`void`	`flushAllCustomIndexesBlocking()` Performs a blocking flush of all custom indexes
`void`	`flushAllIndexesBlocking()` Perform a blocking flush all indexes
`void`	`flushIndexesBlocking(java.util.Set<Index> indexes)` Perform a blocking flush of selected indexes
`java.util.Set<ColumnFamilyStore>`	`getAllIndexColumnFamilyStores()`
`Index`	`getBestIndexFor(ReadCommand command)`
`Index`	`getBestIndexFor(ReadCommand command, boolean includeInTrace)` Called at query time to find the most selective of the registered index implementation (i.e.
`java.util.List<java.lang.String>`	`getBuiltIndexNames()`
`Index`	`getIndex(IndexMetadata metadata)`
`Index`	`getIndexByName(java.lang.String indexName)`
`boolean`	`hasIndexes()`
`void`	`indexPartition(UnfilteredRowIterator partition, OpOrder.Group opGroup, java.util.Set<Index> indexes, int nowInSec)` When building an index against existing data in sstables, add the given partition to the index
`void`	`invalidateAllIndexesBlocking()` Remove all indexes
`java.util.Collection<Index>`	`listIndexes()`
`void`	`markAllIndexesRemoved()` Called when dropping a Table
`CleanupTransaction`	`newCleanupTransaction(DecoratedKey key, PartitionColumns partitionColumns, int nowInSec)` Transaction for use when removing partitions during cleanup
`CompactionTransaction`	`newCompactionTransaction(DecoratedKey key, PartitionColumns partitionColumns, int versions, int nowInSec)` Transaction for use when merging rows during compaction
`UpdateTransaction`	`newUpdateTransaction(PartitionUpdate update, OpOrder.Group opGroup, int nowInSec)` Transaction for updates on the write path.
`void`	`rebuildIndexesBlocking(java.util.Collection<SSTableReader> sstables, java.util.Set<java.lang.String> indexNames)` Does a full, blocking rebuild of the indexes specified by columns from the sstables.
`void`	`registerIndex(Index index)` IndexRegistry methods
`void`	`reload()` Drops and adds new indexes associated with the underlying CF
`void`	`removeIndex(java.lang.String indexName)`
`void`	`truncateAllIndexesBlocking(long truncatedAt)` Truncate all indexes
`void`	`unregisterIndex(Index index)`
`void`	`validate(PartitionUpdate update)` Called at write time to ensure that values present in the update are valid according to the rules of all registered indexes which will process it.

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

- Field Detail
  - baseCfs
```
public final ColumnFamilyStore baseCfs
```
    The underlying column family containing the source data for these indexes
- Constructor Detail
  - SecondaryIndexManager
```
public SecondaryIndexManager(ColumnFamilyStore baseCfs)
```
- Method Detail
  - reload
```
public void reload()
```
    Drops and adds new indexes associated with the underlying CF
  - addIndex
```
public java.util.concurrent.Future<?> addIndex(IndexMetadata indexDef)
```
    Adds and builds a index
    
    Parameters:
    
    indexDef - the IndexMetadata describing the index
  - removeIndex
```
public void removeIndex(java.lang.String indexName)
```
  - markAllIndexesRemoved
```
public void markAllIndexesRemoved()
```
    Called when dropping a Table
  - rebuildIndexesBlocking
```
public void rebuildIndexesBlocking(java.util.Collection<SSTableReader> sstables,
                                   java.util.Set<java.lang.String> indexNames)
```
    Does a full, blocking rebuild of the indexes specified by columns from the sstables. Caller must acquire and release references to the sstables used here. Note also that only this method of (re)building indexes: a) takes a set of index *names* rather than Indexers b) marks exsiting indexes removed prior to rebuilding
    
    Parameters:
    
    sstables - the data to build from
    
    indexNames - the list of indexes to be rebuilt
  - buildAllIndexesBlocking
```
public void buildAllIndexesBlocking(java.util.Collection<SSTableReader> sstables)
```
  - buildIndexBlocking
```
public void buildIndexBlocking(Index index)
```
  - getIndexByName
```
public Index getIndexByName(java.lang.String indexName)
```
  - truncateAllIndexesBlocking
```
public void truncateAllIndexesBlocking(long truncatedAt)
```
    Truncate all indexes
  - invalidateAllIndexesBlocking
```
public void invalidateAllIndexesBlocking()
```
    Remove all indexes
  - flushAllIndexesBlocking
```
public void flushAllIndexesBlocking()
```
    Perform a blocking flush all indexes
  - flushIndexesBlocking
```
public void flushIndexesBlocking(java.util.Set<Index> indexes)
```
    Perform a blocking flush of selected indexes
  - flushAllCustomIndexesBlocking
```
public void flushAllCustomIndexesBlocking()
```
    Performs a blocking flush of all custom indexes
  - getBuiltIndexNames
```
public java.util.List<java.lang.String> getBuiltIndexNames()
```
    Returns:
    
    all indexes which are marked as built and ready to use
  - getAllIndexColumnFamilyStores
```
public java.util.Set<ColumnFamilyStore> getAllIndexColumnFamilyStores()
```
    Returns:
    
    all backing Tables used by registered indexes
  - hasIndexes
```
public boolean hasIndexes()
```
    Returns:
    
    if there are ANY indexes registered for this table
  - indexPartition
```
public void indexPartition(UnfilteredRowIterator partition,
                           OpOrder.Group opGroup,
                           java.util.Set<Index> indexes,
                           int nowInSec)
```
    When building an index against existing data in sstables, add the given partition to the index
  - deletePartition
```
public void deletePartition(UnfilteredRowIterator partition,
                            int nowInSec)
```
    Delete all data from all indexes for this partition. For when cleanup rips a partition out entirely. TODO : improve cleanup transaction to batch updates & perform them async
  - getBestIndexFor
```
public Index getBestIndexFor(ReadCommand command,
                             boolean includeInTrace)
```
    Called at query time to find the most selective of the registered index implementation (i.e. the one likely to return the fewest results) from those registered. Implementation specific validation of the target expression by the most selective index should be performed in the searcherFor method to ensure that we pick the right index regardless of the validity of the expression. This method is called at various points during the lifecycle of a ReadCommand (to obtain a Searcher, get the index's underlying CFS for ReadOrderGroup, or an estimate of the result size from an average index query). Ideally, we would do this relatively expensive operation only once, and attach the index to the ReadCommand for future reference. This requires the index be passed onto additional commands generated to process subranges etc.
    
    Parameters:
    
    command - ReadCommand to be executed
    
    Returns:
    
    an Index instance, ready to use during execution of the command, or null if none of the registered indexes can support the command.
  - getBestIndexFor
```
public Index getBestIndexFor(ReadCommand command)
```
  - validate
```
public void validate(PartitionUpdate update)
              throws InvalidRequestException
```
    Called at write time to ensure that values present in the update are valid according to the rules of all registered indexes which will process it. The partition key as well as the clustering and cell values for each row in the update may be checked by index implementations
    
    Parameters:
    
    update - PartitionUpdate containing the values to be validated by registered Index implementations
    
    Throws:
    
    InvalidRequestException
  - registerIndex
```
public void registerIndex(Index index)
```
    IndexRegistry methods
    
    Specified by:
    
    registerIndex in interface IndexRegistry
  - unregisterIndex
```
public void unregisterIndex(Index index)
```
    Specified by:
    
    unregisterIndex in interface IndexRegistry
  - getIndex
```
public Index getIndex(IndexMetadata metadata)
```
    Specified by:
    
    getIndex in interface IndexRegistry
  - listIndexes
```
public java.util.Collection<Index> listIndexes()
```
    Specified by:
    
    listIndexes in interface IndexRegistry
  - newUpdateTransaction
```
public UpdateTransaction newUpdateTransaction(PartitionUpdate update,
                                              OpOrder.Group opGroup,
                                              int nowInSec)
```
    Transaction for updates on the write path.
  - newCompactionTransaction
```
public CompactionTransaction newCompactionTransaction(DecoratedKey key,
                                                      PartitionColumns partitionColumns,
                                                      int versions,
                                                      int nowInSec)
```
    Transaction for use when merging rows during compaction
  - newCleanupTransaction
```
public CleanupTransaction newCleanupTransaction(DecoratedKey key,
                                                PartitionColumns partitionColumns,
                                                int nowInSec)
```
    Transaction for use when removing partitions during cleanup

Class SecondaryIndexManager

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

baseCfs

Constructor Detail

SecondaryIndexManager

Method Detail

reload

addIndex

removeIndex

markAllIndexesRemoved

rebuildIndexesBlocking

buildAllIndexesBlocking

buildIndexBlocking

getIndexByName

truncateAllIndexesBlocking

invalidateAllIndexesBlocking

flushAllIndexesBlocking

flushIndexesBlocking

flushAllCustomIndexesBlocking

getBuiltIndexNames

getAllIndexColumnFamilyStores

hasIndexes

indexPartition

deletePartition

getBestIndexFor

getBestIndexFor

validate

registerIndex

unregisterIndex

getIndex

listIndexes

newUpdateTransaction

newCompactionTransaction

newCleanupTransaction