org.apache.cassandra.db.compaction

## Class LazilyCompactedRow

- java.lang.Object
- - org.apache.cassandra.db.compaction.AbstractCompactedRow
  - - org.apache.cassandra.db.compaction.LazilyCompactedRow

All Implemented Interfaces:
  java.io.Closeable, java.lang.AutoCloseable, java.lang.Iterable<OnDiskAtom>

    public class LazilyCompactedRow
    extends AbstractCompactedRow
    implements java.lang.Iterable<OnDiskAtom>

LazilyCompactedRow only computes the row bloom filter and column index in memory (at construction time); it does this by reading one column at a time from each of the rows being compacted, and merging them as it does so. So the most we have in memory at a time is the bloom filter, the index, and one column from each pre-compaction row.

### Field Summary

### Fields inherited from class org.apache.cassandra.db.compaction.AbstractCompactedRow

`key`

### Constructor Summary

Constructors
Constructor and Description
`LazilyCompactedRow(CompactionController controller, java.util.List<? extends OnDiskAtomIterator> rows)`

### Method Summary

Methods
`void` `close()`
`ColumnStats` `columnStats()`
`AbstractType<?>` `getComparator()`
`java.util.Iterator<OnDiskAtom>` `iterator()`
`void` `update(java.security.MessageDigest digest)` update @param digest with the data bytes of the row (not including row key or row size).
`RowIndexEntry` `write(long currentPosition, java.io.DataOutput out)` write the row (size + column index + filter + column data, but NOT row key) to @param out.

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

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

### Constructor Detail

#### LazilyCompactedRow

    public LazilyCompactedRow(CompactionController controller,
                      java.util.List<? extends OnDiskAtomIterator> rows)

### Method Detail

#### write

    public RowIndexEntry write(long currentPosition,
                      java.io.DataOutput out)
                        throws java.io.IOException

Description copied from class: `AbstractCompactedRow`
write the row (size + column index + filter + column data, but NOT row key) to @param out. write() may change internal state; it is NOT valid to call write() or update() a second time.

Specified by:
  `write` in class `AbstractCompactedRow`
Returns:
  index information for the written row, or null if the compaction resulted in only expired tombstones.
Throws:
  `java.io.IOException`

#### update

    public void update(java.security.MessageDigest digest)

Description copied from class: `AbstractCompactedRow`
update @param digest with the data bytes of the row (not including row key or row size). May be called even if empty. update() may change internal state; it is NOT valid to call write() or update() a second time.

Specified by:
  `update` in class `AbstractCompactedRow`

#### getComparator

    public AbstractType<?> getComparator()

#### iterator

    public java.util.Iterator<OnDiskAtom> iterator()

Specified by:
  `iterator` in interface `java.lang.Iterable<OnDiskAtom>`

#### columnStats

    public ColumnStats columnStats()

Specified by:
  `columnStats` in class `AbstractCompactedRow`
Returns:
  aggregate information about the columns in this row. Some fields may contain default values if computing them value would require extra effort we're not willing to make.

#### close

    public void close()

Specified by:
  `close` in interface `java.io.Closeable`
Specified by:
  `close` in interface `java.lang.AutoCloseable`