zbuf

type Array ¶

type Array []zed.Value

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.Value)

func (a Array) NewReader() zio.Reader

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

func (a Array) Ref()

func (a Array) Unref()

func (a Array) Values() []zed.Value

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

type Batch ¶

type Batch interface {
	Ref()
	Unref()
	Values() []zed.Value
}

Batch is an interface to a bundle of values. 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 values 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 value from a Batch must retain its Batch reference for as long as it retains the value, and the goroutine must not use the value 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 NewMerger(ctx context.Context, pullers []Puller, cmp expr.CompareFn) *Merger

func (m *Merger) Cancel()

func (m *Merger) Len() int

func (m *Merger) Less(i, j int) bool

func (m *Merger) Pop() interface{}

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

func (m *Merger) Push(x interface{})

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

func (m *Merger) Swap(i, j int)

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 `zed:"bytes_read" json:"bytes_read"`
	BytesMatched   int64 `zed:"bytes_matched" json:"bytes_matched"`
	RecordsRead    int64 `zed:"records_read" json:"records_read"`
	RecordsMatched int64 `zed:"records_matched" json:"records_matched"`
}

ScannerStats holds Scanner statistics.

func (s *ScannerStats) Add(in ScannerStats)

func (s *ScannerStats) Copy() ScannerStats

type Statser ¶

type Statser interface {
	Stats() ScannerStats
}

A Statser produces scanner statistics.