Filter returns a new filteringIter that will filter the Spans from the provided child iterator using the provided FilterFunc.

Get returns the newest span that contains the target key.

NewIter returns a new iterator over a set of fragmented spans.

NewLevelIter returns a LevelIter.

ParseSpan parses the string representation of a Span.

SeekLE seeks to the span that contains or is before the target key.

Sort the spans by start key.

SortKeysByTrailer sorts a keys slice by trailer.

Truncate creates a new iterator where every span in the supplied iterator is truncated to be contained within the range [lower, upper).

VisibleTransform filters keys that are invisible at the provided snapshot sequence number.

BySuffixAsc indicates a Span's keys are sorted by Suffix ascending.

ByTrailerDesc indicates a Span's keys are sorted by Trailer descending.

CoversInvisibly indicates the tested key does fall within the span's bounds and the span contains at least one key with a higher sequence number, but none visible at the provided snapshot.

CoversVisibly indicates the tested key does fall within the span's bounds, and the span constains at least one key with a sequence number higher than the key's sequence number that is visible at the provided snapshot.

NoCover indicates the tested key does not fall within the span's bounds, or the span contains no keys with sequence numbers higher than the key's.

DefragmentInternal configures a DefragmentingIter to defragment spans only if they have identical keys.

StaticDefragmentReducer is a no-op DefragmentReducer that simply returns the current key slice, effectively retaining the first set of keys encountered for a defragmented span.

BoundedIter implements FragmentIterator and enforces bounds.

DefragmentingBuffers holds buffers used for copying iterator state.

DefragmentingIter wraps a key span iterator, defragmenting physical fragmentation during iteration.

Fragmenter fragments a set of spans such that overlapping spans are split at their overlap points.

InterleavingIter combines an iterator over point keys with an iterator over key spans.

InterleavingIterOpts holds options configuring the behavior of a InterleavingIter.

InternalIteratorShim is a temporary iterator type used as a shim between keyspan.MergingIter and base.InternalIterator.

Iter is an iterator over a set of fragmented spans.

Key represents a single key applied over a span of user keys.

KeysBySuffix implements sort.Interface, sorting its member Keys slice to by Suffix in the order dictated by Cmp.

LevelIter provides a merged view of spans from sstables in a level.

MergingBuffers holds buffers used while merging keyspans.

MergingIter merges spans across levels of the LSM, exposing an iterator over spans that yields sets of spans fragmented at unique user key boundaries.

Span represents a set of keys over a span of user key space.

SpanIterOptions is a subset of IterOptions that are necessary to instantiate per-sstable span iterators.

DefragmentMethod configures the defragmentation performed by the DefragmentingIter.

FragmentIterator defines an iterator interface over spans.

A SpanMask may be used to configure an interleaving iterator to skip point keys that fall within the bounds of some spans.

Transformer defines a transformation to be applied to a Span.

Cover is returned by Framenter.Covers and describes a span's relationship to a key at a particular snapshot.

The DefragmentMethodFunc type is an adapter to allow the use of ordinary functions as DefragmentMethods.

DefragmentReducer merges the current and next Key slices, returning a new Key slice.

FilterFunc defines a transform from the input Span into the output Span.

KeysOrder describes the ordering of Keys within a Span.

TableNewSpanIter creates a new iterator for range key spans for the given file.

The TransformerFunc type is an adapter to allow the use of ordinary functions as Transformers.