org.apache.cassandra.db

## Class SuperColumn

- java.lang.Object
- - org.apache.cassandra.db.AbstractColumnContainer
  - - org.apache.cassandra.db.SuperColumn

- All Implemented Interfaces:
    java.lang.Iterable<IColumn>, IColumn, IColumnContainer, OnDiskAtom, IIterableColumns

      public class SuperColumn
      extends AbstractColumnContainer
      implements IColumn

- - ### Nested Class Summary

    - ### Nested classes/interfaces inherited from interface org.apache.cassandra.db.OnDiskAtom

      `OnDiskAtom.Serializer`

  - ### Field Summary

    - ### Fields inherited from class org.apache.cassandra.db.AbstractColumnContainer

      `columns`

    - ### Fields inherited from interface org.apache.cassandra.db.IColumn

      `MAX_NAME_LENGTH`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `SuperColumn(java.nio.ByteBuffer name, AbstractType<?> comparator)`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `addColumn(IColumn column, Allocator allocator)`
    `IColumn` | `cloneMe()`
    `SuperColumn` | `cloneMeShallow()`
    `int` | `dataSize()` This calculates the exact size of the sub columns on the fly
    `IColumn` | `diff(IColumn columnNew)`
    `boolean` | `equals(java.lang.Object o)`
    `int` | `getLocalDeletionTime()`
    `long` | `getMarkedForDeleteAt()`
    `java.lang.String` | `getString(AbstractType<?> comparator)`
    `IColumn` | `getSubColumn(java.nio.ByteBuffer columnName)`
    `java.util.Collection<IColumn>` | `getSubColumns()`
    `int` | `hashCode()`
    `boolean` | `isLive()` For a simple column, live == !isMarkedForDelete.
    `IColumn` | `localCopy(ColumnFamilyStore cfs)` clones the column for the row cache, interning column names and making copies of other underlying byte buffers
    `IColumn` | `localCopy(ColumnFamilyStore cfs, Allocator allocator)` clones the column for the memtable, interning column names and making copies of other underlying byte buffers.
    `long` | `maxTimestamp()` For a standard column, this is the same as timestamp().
    `long` | `minTimestamp()` For a standard column, this is the same as timestamp().
    `long` | `mostRecentLiveChangeAt()`
    `long` | `mostRecentNonGCableChangeAt(int gcbefore)`
    `java.nio.ByteBuffer` | `name()`
    `static OnDiskAtom.Serializer` | `onDiskSerializer(AbstractType<?> comparator)`
    `IColumn` | `reconcile(IColumn c)`
    `IColumn` | `reconcile(IColumn c, Allocator allocator)`
    `int` | `serializationFlags()`
    `int` | `serializedSize(TypeSizes typeSizes)` This returns the size of the super-column when serialized.
    `long` | `serializedSizeForSSTable()`
    `static org.apache.cassandra.db.SuperColumnSerializer` | `serializer(AbstractType<?> comparator)`
    `long` | `timestamp()`
    `void` | `updateDigest(java.security.MessageDigest digest)`
    `void` | `validateFields(CFMetaData metadata)`
    `java.nio.ByteBuffer` | `value()`

    - ### Methods inherited from class org.apache.cassandra.db.AbstractColumnContainer

      `addAll, addAll, addAllWithSizeDelta, addColumn, delete, delete, delete, delete, deletionInfo, getColumn, getColumnCount, getColumnNames, getComparator, getEstimatedColumnCount, getReverseSortedColumns, getSortedColumns, hasIrrelevantData, hasOnlyTombstones, isEmpty, isMarkedForDelete, iterator, iterator, maybeResetDeletionTimes, remove, replace, retainAll, reverseIterator, setDeletionInfo`

    - ### Methods inherited from class java.lang.Object

      `clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait`

    - ### Methods inherited from interface org.apache.cassandra.db.IColumn

      `addColumn, hasIrrelevantData, isMarkedForDelete`

- - ### Constructor Detail

    - #### SuperColumn

          public SuperColumn(java.nio.ByteBuffer name,
                     AbstractType<?> comparator)

  - ### Method Detail

    - #### serializer

          public static org.apache.cassandra.db.SuperColumnSerializer serializer(AbstractType<?> comparator)

    - #### onDiskSerializer

          public static OnDiskAtom.Serializer onDiskSerializer(AbstractType<?> comparator)

    - #### cloneMeShallow

          public SuperColumn cloneMeShallow()

    - #### cloneMe

          public IColumn cloneMe()

    - #### name

          public java.nio.ByteBuffer name()

      Specified by:
        `name` in interface `OnDiskAtom`

    - #### getSubColumns

          public java.util.Collection<IColumn> getSubColumns()

      Specified by:
        `getSubColumns` in interface `IColumn`

    - #### getSubColumn

          public IColumn getSubColumn(java.nio.ByteBuffer columnName)

      Specified by:
        `getSubColumn` in interface `IColumn`

    - #### dataSize

          public int dataSize()

      This calculates the exact size of the sub columns on the fly
      Specified by:
        `dataSize` in interface `IColumn`

    - #### serializedSize

          public int serializedSize(TypeSizes typeSizes)

      This returns the size of the super-column when serialized.
      Specified by:
        `serializedSize` in interface `OnDiskAtom`
      See Also:
        `OnDiskAtom.serializedSize(TypeSizes)`

    - #### serializedSizeForSSTable

          public long serializedSizeForSSTable()

      Specified by:
        `serializedSizeForSSTable` in interface `OnDiskAtom`

    - #### timestamp

          public long timestamp()

      Specified by:
        `timestamp` in interface `IColumn`

    - #### minTimestamp

          public long minTimestamp()

      Description copied from interface: `OnDiskAtom`
      For a standard column, this is the same as timestamp(). For a super column, this is the min/max column timestamp of the sub columns.
      Specified by:
        `minTimestamp` in interface `OnDiskAtom`

    - #### maxTimestamp

          public long maxTimestamp()

      Description copied from interface: `IColumn`
      For a standard column, this is the same as timestamp(). For a super column, this is the max column timestamp of the sub columns.
      Specified by:
        `maxTimestamp` in interface `IColumn`
      Specified by:
        `maxTimestamp` in interface `OnDiskAtom`

    - #### mostRecentLiveChangeAt

          public long mostRecentLiveChangeAt()

      Specified by:
        `mostRecentLiveChangeAt` in interface `IColumn`

    - #### getMarkedForDeleteAt

          public long getMarkedForDeleteAt()

      Specified by:
        `getMarkedForDeleteAt` in interface `IColumn`

    - #### getLocalDeletionTime

          public int getLocalDeletionTime()

      Specified by:
        `getLocalDeletionTime` in interface `OnDiskAtom`

    - #### mostRecentNonGCableChangeAt

          public long mostRecentNonGCableChangeAt(int gcbefore)

      Specified by:
        `mostRecentNonGCableChangeAt` in interface `IColumn`

    - #### value

          public java.nio.ByteBuffer value()

      Specified by:
        `value` in interface `IColumn`

    - #### addColumn

          public void addColumn(IColumn column,
                       Allocator allocator)

      Specified by:
        `addColumn` in interface `IColumn`
      Specified by:
        `addColumn` in interface `IColumnContainer`
      Overrides:
        `addColumn` in class `AbstractColumnContainer`

    - #### diff

          public IColumn diff(IColumn columnNew)

      Specified by:
        `diff` in interface `IColumn`

    - #### updateDigest

          public void updateDigest(java.security.MessageDigest digest)

      Specified by:
        `updateDigest` in interface `OnDiskAtom`

    - #### getString

          public java.lang.String getString(AbstractType<?> comparator)

      Specified by:
        `getString` in interface `IColumn`

    - #### isLive

          public boolean isLive()

      Description copied from interface: `IColumn`
      For a simple column, live == !isMarkedForDelete. For a supercolumn, live means it has at least one subcolumn whose timestamp is greater than the supercolumn deleted-at time.
      Specified by:
        `isLive` in interface `IColumn`

    - #### localCopy

          public IColumn localCopy(ColumnFamilyStore cfs)

      Description copied from interface: `IColumn`
      clones the column for the row cache, interning column names and making copies of other underlying byte buffers
      Specified by:
        `localCopy` in interface `IColumn`

    - #### localCopy

          public IColumn localCopy(ColumnFamilyStore cfs,
                          Allocator allocator)

      Description copied from interface: `IColumn`
      clones the column for the memtable, interning column names and making copies of other underlying byte buffers. Unlike the other localCopy, this uses Allocator to allocate values in contiguous memory regions, which helps avoid heap fragmentation.
      Specified by:
        `localCopy` in interface `IColumn`

    - #### reconcile

          public IColumn reconcile(IColumn c)

      Specified by:
        `reconcile` in interface `IColumn`

    - #### reconcile

          public IColumn reconcile(IColumn c,
                          Allocator allocator)

      Specified by:
        `reconcile` in interface `IColumn`

    - #### serializationFlags

          public int serializationFlags()

      Specified by:
        `serializationFlags` in interface `IColumn`

    - #### validateFields

          public void validateFields(CFMetaData metadata)
                              throws MarshalException

      Specified by:
        `validateFields` in interface `IColumn`
      Specified by:
        `validateFields` in interface `OnDiskAtom`
      Throws:
        `MarshalException`

    - #### equals

          public boolean equals(java.lang.Object o)

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

    - #### hashCode

          public int hashCode()

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

Copyright © 2014 The Apache Software Foundation