Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

expr

package

Go to main page

Versions in this module

v0

v0.33.0

Nov 17, 2021

v0.32.0

Nov 3, 2021

Changes in this version

type Boolean

+ func CompareBytes(op string, pattern []byte) (Boolean, error)

v0.31.0

Oct 4, 2021

Changes in this version

+ var ErrBadCast = errors.New("bad cast")

+ var ErrBadValue = errors.New("bad value")

+ var ErrFieldRequired = errors.New("field parameter required")

+ var ErrIncompatibleTypes = coerce.ErrIncompatibleTypes

+ var ErrIndexOutOfBounds = errors.New("array index out of bounds")

+ var ErrNotContainer = errors.New("cannot apply in to a non-container")

+ var ErrSliceIndex = errors.New("slice index is not a number")

+ var ErrSliceIndexEmpty = errors.New("slice index is empty")

+ func CompileRegexp(pattern string) (*regexp.Regexp, error)

+ func DotExprToField(e Evaluator) (field.Path, error)

+ func DotExprToString(e Evaluator) (string, error)

+ func FlattenColumns(cols []zed.Column) []zed.Column

+ func LookupCompare(typ zed.Type) comparefn

+ func SortStable(records []*zed.Record, compare CompareFn)

+ type Add struct

+ func (a *Add) Eval(rec *zed.Record) (zed.Value, error)

+ type AggExpr struct

+ func NewAggExpr(zctx *zed.Context, pattern agg.Pattern, src Generator) *AggExpr

+ func (a *AggExpr) Eval(rec *zed.Record) (zed.Value, error)

+ type Aggregator struct

+ func NewAggregator(op string, expr Evaluator, where Filter) (*Aggregator, error)

+ func (a *Aggregator) Apply(f agg.Function, rec *zed.Record) error

+ func (a *Aggregator) NewFunction() agg.Function

+ type And struct

+ func NewLogicalAnd(lhs, rhs Evaluator) *And

+ func (a *And) Eval(rec *zed.Record) (zed.Value, error)

+ type ArrayExpr struct

+ func NewArrayExpr(zctx *zed.Context, exprs []Evaluator) *ArrayExpr

+ func (a *ArrayExpr) Eval(rec *zed.Record) (zed.Value, error)

+ type Assignment struct

+ LHS field.Path

+ RHS Evaluator

+ type Boolean func(zed.Value) bool

+ func CompareBool(op string, pattern bool) (Boolean, error)

+ func CompareBstring(op string, pattern []byte) (Boolean, error)

+ func CompareFloat64(op string, pattern float64) (Boolean, error)

+ func CompareIP(op string, pattern net.IP) (Boolean, error)

+ func CompareInt64(op string, pattern int64) (Boolean, error)

+ func CompareSubnet(op string, pattern *net.IPNet) (Boolean, error)

+ func CompareTime(op string, pattern int64) (Boolean, error)

+ func CompareUnset(op string) (Boolean, error)

+ func Comparison(op string, primitive astzed.Primitive) (Boolean, error)

+ func Contains(compare Boolean) Boolean

+ func NewRegexpBoolean(re *regexp.Regexp) Boolean

+ type BufferFilter struct

+ func NewAndBufferFilter(left, right *BufferFilter) *BufferFilter

+ func NewBufferFilterForString(pattern string) *BufferFilter

+ func NewBufferFilterForStringCase(pattern string) *BufferFilter

+ func NewFieldNameFinder(pattern string) *BufferFilter

+ func NewOrBufferFilter(left, right *BufferFilter) *BufferFilter

+ func (b *BufferFilter) Eval(zctx *zed.Context, buf []byte) bool

+ type Call struct

+ AddRoot bool

+ func NewCall(zctx *zed.Context, fn function.Interface, exprs []Evaluator) *Call

+ func (c *Call) Eval(rec *zed.Record) (zed.Value, error)

+ type Compare struct

+ func NewCompareRelative(lhs, rhs Evaluator, operator string) (*Compare, error)

+ func (c *Compare) Eval(rec *zed.Record) (zed.Value, error)

+ type CompareFn func(a *zed.Record, b *zed.Record) int

+ func NewCompareFn(nullsMax bool, fields ...Evaluator) CompareFn

+ type Conditional struct

+ func NewConditional(predicate, thenExpr, elseExpr Evaluator) *Conditional

+ func (c *Conditional) Eval(rec *zed.Record) (zed.Value, error)

+ type ConstShaper struct

+ func NewConstShaper(zctx *zed.Context, expr Evaluator, shapeTo zed.Type, tf ShaperTransform) *ConstShaper

+ func (c *ConstShaper) Eval(in *zed.Record) (zed.Value, error)

+ func (s *ConstShaper) Apply(in *zed.Record) (*zed.Record, error)

+ type Cutter struct

+ func NewCutter(zctx *zed.Context, fieldRefs field.List, fieldExprs []Evaluator) (*Cutter, error)

+ func (_ *Cutter) String() string

+ func (c *Cutter) AllowPartialCuts()

+ func (c *Cutter) Apply(in *zed.Record) (*zed.Record, error)

+ func (c *Cutter) Eval(rec *zed.Record) (zed.Value, error)

+ func (c *Cutter) FoundCut() bool

+ func (c *Cutter) Quiet()

+ func (c *Cutter) Warning() string

+ type Divide struct

+ func (d *Divide) Eval(rec *zed.Record) (zed.Value, error)

+ type DotExpr struct

+ func NewDotAccess(record Evaluator, field string) *DotExpr

+ func (f *DotExpr) Eval(rec *zed.Record) (zed.Value, error)

+ type Dropper struct

+ func NewDropper(zctx *zed.Context, fields field.List) *Dropper

+ func (_ *Dropper) String() string

+ func (_ *Dropper) Warning() string

+ func (d *Dropper) Apply(in *zed.Record) (*zed.Record, error)

+ type Entry struct

+ Key Evaluator

+ Val Evaluator

+ type Equal struct

+ func NewCompareEquality(lhs, rhs Evaluator, operator string) (*Equal, error)

+ func (e *Equal) Eval(rec *zed.Record) (zed.Value, error)

+ type Evaluator interface

+ Eval func(*zed.Record) (zed.Value, error)

+ func NewArithmetic(lhs, rhs Evaluator, op string) (Evaluator, error)

+ func NewCast(expr Evaluator, typ zed.Type) (Evaluator, error)

+ func NewDotExpr(f field.Path) Evaluator

+ func NewIndexExpr(zctx *zed.Context, container, index Evaluator) (Evaluator, error)

+ func NewRootField(name string) Evaluator

+ type Exists struct

+ func NewExists(zctx *zed.Context, exprs []Evaluator) *Exists

+ func (e *Exists) Eval(rec *zed.Record) (zed.Value, error)

+ type Filter func(*zed.Record) bool

+ func Apply(e Evaluator, pred Boolean) Filter

+ func EvalAny(eval Boolean, recursive bool) Filter

+ func LogicalAnd(left, right Filter) Filter

+ func LogicalNot(expr Filter) Filter

+ func LogicalOr(left, right Filter) Filter

+ func SearchRecordOther(searchtext string, searchval astzed.Primitive) (Filter, error)

+ func SearchRecordString(term string) Filter

+ type FilterEvaluator Filter

+ func (f FilterEvaluator) Eval(rec *zed.Record) (zed.Value, error)

+ type FilterMethod struct

+ func NewFilterMethod(src Generator) *FilterMethod

+ func (f *FilterMethod) Init(rec *zed.Record)

+ func (f *FilterMethod) Next() (zed.Value, error)

+ func (f *FilterMethod) Ref() *zed.Value

+ func (f *FilterMethod) Set(e Evaluator)

+ type Flattener struct

+ func NewFlattener(zctx *zed.Context) *Flattener

+ func (f *Flattener) Flatten(r *zed.Record) (*zed.Record, error)

+ type Generator interface

+ Init func(*zed.Record)

+ Next func() (zed.Value, error)

+ type Has struct

+ func NewHas(exprs []Evaluator) *Has

+ func (h *Has) Eval(rec *zed.Record) (zed.Value, error)

+ type In struct

+ func NewIn(elem, container Evaluator) *In

+ func (i *In) Eval(rec *zed.Record) (zed.Value, error)

+ type Index struct

+ func (i *Index) Eval(rec *zed.Record) (zed.Value, error)

+ type KeyCompareFn func(*zed.Record) int

+ func NewKeyCompareFn(key *zed.Record) (KeyCompareFn, error)

+ type Literal struct

+ func NewLiteral(zv zed.Value) *Literal

+ func (l *Literal) Eval(*zed.Record) (zed.Value, error)

+ type MapExpr struct

+ func NewMapExpr(zctx *zed.Context, entries []Entry) *MapExpr

+ func (m *MapExpr) Eval(rec *zed.Record) (zed.Value, error)

+ type MapMethod struct

+ func NewMapMethod(src Generator) *MapMethod

+ func (m *MapMethod) Init(rec *zed.Record)

+ func (m *MapMethod) Next() (zed.Value, error)

+ func (m *MapMethod) Ref() *zed.Value

+ func (m *MapMethod) Set(e Evaluator)

+ type Missing struct

+ func NewMissing(exprs []Evaluator) *Missing

+ func (m *Missing) Eval(rec *zed.Record) (zed.Value, error)

+ type Multiply struct

+ func (m *Multiply) Eval(rec *zed.Record) (zed.Value, error)

+ type Not struct

+ func NewLogicalNot(e Evaluator) *Not

+ func (n *Not) Eval(rec *zed.Record) (zed.Value, error)

+ type Or struct

+ func NewLogicalOr(lhs, rhs Evaluator) *Or

+ func (o *Or) Eval(rec *zed.Record) (zed.Value, error)

+ type PrimitiveCaster func(zv zed.Value) (zed.Value, error)

+ func LookupPrimitiveCaster(typ zed.Type) PrimitiveCaster

+ type RecordExpr struct

+ func NewRecordExpr(zctx *zed.Context, names []string, exprs []Evaluator) *RecordExpr

+ func (r *RecordExpr) Eval(rec *zed.Record) (zed.Value, error)

+ type RecordSlice struct

+ func NewRecordSlice(compare CompareFn) *RecordSlice

+ func (r *RecordSlice) Index(i int) *zed.Record

+ func (r *RecordSlice) Len() int

+ func (r *RecordSlice) Less(i, j int) bool

+ func (r *RecordSlice) Pop() interface{}

+ func (r *RecordSlice) Push(rec interface{})

+ func (r *RecordSlice) Swap(i, j int)

+ type RegexpMatch struct

+ func NewRegexpMatch(re *regexp.Regexp, e Evaluator) *RegexpMatch

+ func (r *RegexpMatch) Eval(rec *zed.Record) (zed.Value, error)

+ type RootRecord struct

+ func (r *RootRecord) Eval(rec *zed.Record) (zed.Value, error)

+ type Selector struct

+ func NewSelector(selectors []Evaluator) *Selector

+ func (s *Selector) Init(rec *zed.Record)

+ func (s *Selector) Next() (zed.Value, error)

+ type SetExpr struct

+ func NewSetExpr(zctx *zed.Context, exprs []Evaluator) *SetExpr

+ func (s *SetExpr) Eval(rec *zed.Record) (zed.Value, error)

+ type Shaper struct

+ func NewShaper(zctx *zed.Context, expr, typExpr Evaluator, tf ShaperTransform) *Shaper

+ func (s *Shaper) Eval(rec *zed.Record) (zed.Value, error)

+ type ShaperTransform int

+ const Cast

+ const Crop

+ const Fill

+ const Order

+ type Slice struct

+ func NewSlice(elem, from, to Evaluator) *Slice

+ func (s *Slice) Eval(rec *zed.Record) (zed.Value, error)

+ type Subtract struct

+ func (s *Subtract) Eval(rec *zed.Record) (zed.Value, error)

+ type TypeFunc struct

+ func NewTypeFunc(zctx *zed.Context, name string) *TypeFunc

+ func (t *TypeFunc) Eval(rec *zed.Record) (zed.Value, error)

+ type Unflattener struct

+ func NewUnflattener(zctx *zed.Context) *Unflattener

+ func (c *Unflattener) Eval(rec *zed.Record) (zed.Value, error)

+ func (u *Unflattener) Apply(in *zed.Record) (*zed.Record, error)

+ type ValueCompareFn func(a zed.Value, b zed.Value) int

+ func NewValueCompareFn(nullsMax bool) ValueCompareFn

+ type Var struct

+ func NewVar(ref *zed.Value) *Var

+ func (v *Var) Eval(*zed.Record) (zed.Value, error)

v0.30.0

Sep 13, 2021