Class RowIndexEntry<T>

  • All Implemented Interfaces:
    IMeasurableMemory

    public class RowIndexEntry<T>
    extends java.lang.Object
    implements IMeasurableMemory
    Binary format of RowIndexEntry is defined as follows: (long) position (64 bit long, vint encoded) (int) serialized size of data that follows (32 bit int, vint encoded) -- following for indexed entries only (so serialized size > 0) (int) DeletionTime.localDeletionTime (long) DeletionTime.markedForDeletionAt (int) number of IndexInfo objects (32 bit int, vint encoded) (*) serialized IndexInfo objects, see below (*) offsets of serialized IndexInfo objects, since version "ma" (3.0) Each IndexInfo object's offset is relative to the first IndexInfo object.

    See IndexInfo for a description of the serialized format.

    For each partition, the layout of the index file looks like this:

    1. partition key - prefixed with short length
    2. serialized RowIndexEntry objects

    Generally, we distinguish between index entries that have index samples (list of IndexInfo objects) and those who don't. For each portion of data for a single partition in the data file, an index sample is created. The size of that portion is defined by Config.column_index_size_in_kb.

    Index entries with less than 2 index samples, will just store the position in the data file.

    Note: legacy sstables for index entries are those sstable formats that do not have an offsets table to index samples (IndexInfo objects). These are those sstables created on Cassandra versions earlier than 3.0.

    For index entries with index samples we store the index samples (IndexInfo objects). The bigger the partition, the more index samples are created. Since a huge amount of index samples will "pollute" the heap and cause huge GC pressure, Cassandra 3.6 (CASSANDRA-11206) distinguishes between index entries with an "acceptable" amount of index samples per partition and those with an "enormous" amount of index samples. The barrier is controlled by the configuration parameter Config.column_index_cache_size_in_kb. Index entries with a total serialized size of index samples up to column_index_cache_size_in_kb will be held in an array. Index entries exceeding that value will always be accessed from disk.

    This results in these classes:

    Since access to index samples on disk (obviously) requires some file reader, that functionality is encapsulated in implementations of RowIndexEntry.IndexInfoRetriever. There is an implementation to access index samples of legacy sstables (without the offsets table), an implementation of access sstables with an offsets table.

    Until now (Cassandra 3.x), we still support reading from legacy sstables - i.e. sstables created by Cassandra < 3.0 (see BigFormat.

    • Field Detail

      • position

        public final long position
    • Constructor Detail

      • RowIndexEntry

        public RowIndexEntry​(long position)
    • Method Detail

      • isIndexed

        public boolean isIndexed()
        Returns:
        true if this index entry contains the row-level tombstone and column summary. Otherwise, caller should fetch these from the row header.
      • indexOnHeap

        public boolean indexOnHeap()
      • columnsIndexCount

        public int columnsIndexCount()
      • unsharedHeapSize

        public long unsharedHeapSize()
        Specified by:
        unsharedHeapSize in interface IMeasurableMemory
        Returns:
        the amount of on-heap memory retained by the object that might be reclaimed if the object were reclaimed, i.e. it should try to exclude globally cached data where possible, or counting portions of arrays that are referenced by the object but used by other objects only (e.g. slabbed byte-buffers), etc.
      • serialize

        public void serialize​(DataOutputPlus out,
                              java.nio.ByteBuffer indexInfo)
                       throws java.io.IOException
        Throws:
        java.io.IOException
      • serializeForCache

        public void serializeForCache​(DataOutputPlus out)
                               throws java.io.IOException
        Throws:
        java.io.IOException