zbuf

type Array ¶

type Array []*zed.Record

Array is a slice of of records that implements the Batch and the Reader interfaces.

func ReadAll(r zio.Reader) (arr Array, err error)

func (a *Array) Append(r *zed.Record)

func (a Array) Index(k int) *zed.Record

func (a Array) Length() int

func (a Array) NewReader() zio.Reader

func (a *Array) Read() (*zed.Record, error)

func (a Array) Records() []*zed.Record

func (a Array) Ref()

func (a Array) Unref()

func (a *Array) Write(r *zed.Record) error

type Batch ¶

type Batch interface {
	Ref()
	Unref()
	Index(int) *zed.Record
	Length() int
	Records() []*zed.Record
}

Batch is an interface to a bundle of records. Reference counting allows efficient, safe reuse in concert with sharing across goroutines.

A newly obtained Batch always has a reference count of one. The Batch owns its records and their storage, and an implementation may reuse this memory when the reference count falls to zero, reducing load on the garbage collector.

To promote reuse, a goroutine should release a Batch reference when possible, but care must be taken to avoid race conditions that arise from releasing a reference too soon. Specifically, a goroutine obtaining a *zed.Record from a Batch must retain its Batch reference for as long as it retains the pointer, and the goroutine must not use the pointer after releasing its reference.

Regardless of reference count or implementation, an unreachable Batch will eventually be reclaimed by the garbage collector.

type File ¶

type File struct {
	zio.Reader
	// contains filtered or unexported fields
}

func NewFile(r zio.Reader, c io.Closer, name string) *File

func (r *File) Close() error

func (r *File) String() string

type Filter ¶

type Filter interface {
	AsFilter() (expr.Filter, error)
	AsBufferFilter() (*expr.BufferFilter, error)
}

type Merger ¶

type Merger struct {
	// contains filtered or unexported fields
}

A Merger merges multiple upstream Pullers into one downstream Puller. If the input streams are ordered according to the configured comparison, the output of Merger will have the same order. Each parent puller is run in its own goroutine so that deadlock is avoided when the upstream pullers would otherwise block waiting for an adjacent puller to finish but the Merger is waiting on the upstream puller.

func MergeByTs(ctx context.Context, pullers []Puller, o order.Which) *Merger

func NewMerger(ctx context.Context, pullers []Puller, cmp expr.CompareFn) *Merger

func (m *Merger) Cancel()

func (m *Merger) Pull() (Batch, error)

func (m *Merger) Read() (*zed.Record, error)

type MultiStats ¶

type MultiStats []Scanner

func (m MultiStats) Stats() ScannerStats

type Puller ¶

type Puller interface {
	Pull() (Batch, error)
}

A Puller produces Batches of records, signaling end-of-stream by returning a nil Batch and nil error.

func NewPuller(zr zio.Reader, n int) Puller

type PullerCloser ¶

type PullerCloser interface {
	Puller
	io.Closer
}

type Scanner ¶

type Scanner interface {
	Statser
	Puller
}

A Scanner is a Batch source that also provides statistics.

func NewScanner(ctx context.Context, r zio.Reader, filterExpr Filter) (Scanner, error)

type ScannerAble ¶

type ScannerAble interface {
	NewScanner(ctx context.Context, filterExpr Filter) (Scanner, error)
}

ScannerAble is implemented by Readers that provide an optimized implementation of the Scanner interface.

type ScannerCloser ¶

type ScannerCloser interface {
	Scanner
	io.Closer
}

type ScannerStats ¶

type ScannerStats struct {
	BytesRead      int64
	BytesMatched   int64
	RecordsRead    int64
	RecordsMatched int64
}

ScannerStats holds Scanner statistics. It should be identical to api.ScannerStats.

func (s *ScannerStats) Add(in ScannerStats)

func (s *ScannerStats) Copy() ScannerStats

type Statser ¶

type Statser interface {
	Stats() ScannerStats
}

A Statser produces scanner statistics.