ast

type Agg ¶

type Agg struct {
	Kind  string `json:"kind" unpack:""`
	Name  string `json:"name"`
	Expr  Expr   `json:"expr"`
	Where Expr   `json:"where"`
}

An Agg is an AST node that represents a aggregate function. The Name field indicates the aggregation method while the Expr field indicates an expression applied to the incoming records that is operated upon by them aggregate function. If Expr isn't present, then the aggregator doesn't act upon a function of the record, e.g., count() counts up records without looking into them.

func (*Agg) ExprAST()

type ArrayExpr ¶

type ArrayExpr struct {
	Kind  string `json:"kind" unpack:""`
	Exprs []Expr `json:"exprs"`
}

func (*ArrayExpr) ExprAST()

type Assignment ¶

type Assignment struct {
	Kind string `json:"kind" unpack:""`
	LHS  Expr   `json:"lhs"`
	RHS  Expr   `json:"rhs"`
}

func NewAggAssignment(kind string, lval field.Path, arg field.Path) Assignment

func (*Assignment) ExprAST()

type BinaryExpr ¶

type BinaryExpr struct {
	Kind string `json:"kind" unpack:""`
	Op   string `json:"op"`
	LHS  Expr   `json:"lhs"`
	RHS  Expr   `json:"rhs"`
}

A BinaryExpr is any expression of the form "lhs kind rhs" including arithmetic (+, -, *, /), logical operators (and, or), comparisons (=, !=, <, <=, >, >=), index operatons (on arrays, sets, and records) with kind "[" and a dot expression (".") (on records).

func (*BinaryExpr) ExprAST()

type Call ¶

type Call struct {
	Kind  string `json:"kind" unpack:""`
	Name  string `json:"name"`
	Args  []Expr `json:"args"`
	Where Expr   `json:"where"`
}

A Call represents different things dependending on its context. As a proc, it is either a group-by with no group-by keys and no duration, or a filter with a function that is boolean valued. This is determined by the compiler rather than the syntax tree based on the specific functions and aggregators that are defined at compile time. In expression context, a function call has the standard semantics where it takes one or more arguments and returns a result.

func (*Call) ExprAST()

type Case ¶

type Case struct {
	Expr Expr `json:"expr"`
	Proc Proc `json:"proc"`
}

type Cast ¶

type Cast struct {
	Kind string `json:"kind" unpack:""`
	Expr Expr   `json:"expr"`
	Type Expr   `json:"type"`
}

func (*Cast) ExprAST()

type Conditional ¶

type Conditional struct {
	Kind string `json:"kind" unpack:""`
	Cond Expr   `json:"cond"`
	Then Expr   `json:"then"`
	Else Expr   `json:"else"`
}

func (*Conditional) ExprAST()

type Cut ¶

type Cut struct {
	Kind string       `json:"kind" unpack:""`
	Args []Assignment `json:"args"`
}

A Cut proc represents a proc that removes fields from each input record where each removed field matches one of the named fields sending each such modified record to its output in the order received.

func (*Cut) ProcAST()

type Def ¶ added in v1.0.0

type Def struct {
	Name string `json:"name"`
	Expr Expr   `json:"expr"`
}

Def is like Assignment but the LHS is an identifier that may be later referenced. This is used for const blocks in Sequential and var blocks in a let scope.

type Drop ¶

type Drop struct {
	Kind string `json:"kind" unpack:""`
	Args []Expr `json:"args"`
}

A Drop proc represents a proc that removes fields from each input record.

func (*Drop) ProcAST()

type EntryExpr ¶

type EntryExpr struct {
	Key   Expr `json:"key"`
	Value Expr `json:"value"`
}

type Explode ¶

type Explode struct {
	Kind string      `json:"kind" unpack:""`
	Args []Expr      `json:"args"`
	Type astzed.Type `json:"type"`
	As   Expr        `json:"as"`
}

func (*Explode) ProcAST()

type Expr ¶

type Expr interface {
	ExprAST()
}

func NewDotExpr(f field.Path) Expr

func UnpackMapAsExpr(m interface{}) (Expr, error)

type Field ¶ added in v1.0.0

type Field struct {
	Kind  string `json:"kind" unpack:""`
	Name  string `json:"name"`
	Value Expr   `json:"value"`
}

type File ¶

type File struct {
	Kind   string  `json:"kind" unpack:""`
	Path   string  `json:"path"`
	Format string  `json:"format"`
	Layout *Layout `json:"layout"`
}

func (*File) Source()

type From ¶

type From struct {
	Kind   string  `json:"kind" unpack:""`
	Trunks []Trunk `json:"trunks"`
}

A proc is a node in the flowgraph that takes records in, processes them, and produces records as output.

func (*From) ProcAST()

type Fuse ¶

type Fuse struct {
	Kind string `json:"kind" unpack:""`
}

A Fuse proc represents a proc that turns a zng stream into a dataframe.

func (*Fuse) ProcAST()

type Glob ¶ added in v1.0.0

type Glob struct {
	Kind    string `json:"kind" unpack:""`
	Pattern string `json:"pattern"`
}

func (*Glob) ExprAST()

func (*Glob) PatternAST()

type Grep ¶ added in v1.0.0

type Grep struct {
	Kind    string  `json:"kind" unpack:""`
	Pattern Pattern `json:"pattern"`
	Expr    Expr    `json:"expr"`
}

func (*Grep) ExprAST()

type HTTP ¶

type HTTP struct {
	Kind   string  `json:"kind" unpack:""`
	URL    string  `json:"url"`
	Format string  `json:"format"`
	Layout *Layout `json:"layout"`
}

func (*HTTP) Source()

type Head ¶

type Head struct {
	Kind  string `json:"kind" unpack:""`
	Count int    `json:"count"`
}

A Head proc represents a proc that forwards the indicated number of records then terminates.

func (*Head) ProcAST()

type ID ¶

type ID struct {
	Kind string `json:"kind" unpack:""`
	Name string `json:"name"`
}

func (*ID) ExprAST()

type Join ¶

type Join struct {
	Kind     string       `json:"kind" unpack:""`
	Style    string       `json:"style"`
	LeftKey  Expr         `json:"left_key"`
	RightKey Expr         `json:"right_key"`
	Args     []Assignment `json:"args"`
}

A Join proc represents a proc that joins two zng streams.

func (*Join) ProcAST()

type Layout ¶

type Layout struct {
	Kind  string `json:"kind" unpack:""`
	Keys  []Expr `json:"keys"`
	Order string `json:"order"`
}

func NewLayout(layout order.Layout) *Layout

type Let ¶ added in v1.0.0

type Let struct {
	Kind   string `json:"kind" unpack:""`
	Locals []Def  `json:"locals"`
	Over   *Over  `json:"over"`
}

A proc is a node in the flowgraph that takes records in, processes them, and produces records as output.

func (*Let) ProcAST()

type MapExpr ¶

type MapExpr struct {
	Kind    string      `json:"kind" unpack:""`
	Entries []EntryExpr `json:"entries"`
}

func (*MapExpr) ExprAST()

type Merge ¶ added in v1.0.0

type Merge struct {
	Kind string `json:"kind" unpack:""`
	Expr Expr   `json:"expr"`
}

A proc is a node in the flowgraph that takes records in, processes them, and produces records as output.

func (*Merge) ProcAST()

type OpAssignment ¶

type OpAssignment struct {
	Kind        string       `json:"kind" unpack:""`
	Assignments []Assignment `json:"assignments"`
}

An OpAssignment proc is a list of assignments whose parent proc is unknown: It could be a Summarize or Put proc. This will be determined in the semantic phase.

func (*OpAssignment) ProcAST()

type OpExpr ¶ added in v1.0.0

type OpExpr struct {
	Kind string `json:"kind" unpack:""`
	Expr Expr   `json:"expr"`
}

An OpExpr operator is an expression that appears as an operator and requires semantic analysis to determine if it is a filter, a yield, or an aggregation.

func (*OpExpr) ProcAST()

type Over ¶ added in v1.0.0

type Over struct {
	Kind  string      `json:"kind" unpack:""`
	Exprs []Expr      `json:"exprs"`
	As    string      `json:"as"`
	Scope *Sequential `json:"scope"`
}

A proc is a node in the flowgraph that takes records in, processes them, and produces records as output.

func (*Over) ProcAST()

type Parallel ¶

type Parallel struct {
	Kind string `json:"kind" unpack:""`
	// If non-zero, MergeBy contains the field name on
	// which the branches of this parallel proc should be
	// merged in the order indicated by MergeReverse.
	// XXX merge_by should be a list of expressions
	MergeBy      field.Path `json:"merge_by,omitempty"`
	MergeReverse bool       `json:"merge_reverse,omitempty"`
	Procs        []Proc     `json:"procs"`
}

A Parallel proc represents a set of procs that each get a stream of records from their parent.

func (*Parallel) ProcAST()

type Pass ¶

type Pass struct {
	Kind string `json:"kind" unpack:""`
}

A Pass proc represents a passthrough proc that mirrors incoming Pull()s on its parent and returns the result.

func (*Pass) ProcAST()

func (*Pass) Source()

type Pattern ¶ added in v1.0.0

type Pattern interface {
	PatternAST()
}

type Pool ¶

type Pool struct {
	Kind      string   `json:"kind" unpack:""`
	Spec      PoolSpec `json:"spec"`
	At        string   `json:"at"`
	Range     *Range   `json:"range"`
	ScanOrder string   `json:"scan_order"` // asc, desc, or unknown
}

func (*Pool) Source()

type PoolSpec ¶

type PoolSpec struct {
	Pool   string `json:"pool"`
	Commit string `json:"commit"`
	Meta   string `json:"meta"`
}

type Proc ¶

type Proc interface {
	ProcAST()
}

Proc is the interface implemented by all AST processor nodes.

func Copy(in Proc) Proc

func UnpackJSONAsProc(buf []byte) (Proc, error)

func UnpackMapAsProc(m interface{}) (Proc, error)

type Put ¶

type Put struct {
	Kind string       `json:"kind" unpack:""`
	Args []Assignment `json:"args"`
}

A proc is a node in the flowgraph that takes records in, processes them, and produces records as output.

func (*Put) ProcAST()

type Range ¶

type Range struct {
	Kind  string `json:"kind" unpack:""`
	Lower Expr   `json:"lower"`
	Upper Expr   `json:"upper"`
}

type RecordElem ¶ added in v1.0.0

type RecordElem interface {
	// contains filtered or unexported methods
}

type RecordExpr ¶

type RecordExpr struct {
	Kind  string       `json:"kind" unpack:""`
	Elems []RecordElem `json:"elems"`
}

func (*RecordExpr) ExprAST()

type Regexp ¶ added in v1.0.0

type Regexp struct {
	Kind    string `json:"kind" unpack:""`
	Pattern string `json:"pattern"`
}

func (*Regexp) ExprAST()

func (*Regexp) PatternAST()

type Rename ¶

type Rename struct {
	Kind string       `json:"kind" unpack:""`
	Args []Assignment `json:"args"`
}

A Rename proc represents a proc that renames fields.

func (*Rename) ProcAST()

type SQLExpr ¶

type SQLExpr struct {
	Kind    string       `json:"kind" unpack:""`
	Select  []Assignment `json:"select"`
	From    *SQLFrom     `json:"from"`
	Joins   []SQLJoin    `json:"joins"`
	Where   Expr         `json:"where"`
	GroupBy []Expr       `json:"group_by"`
	Having  Expr         `json:"having"`
	OrderBy *SQLOrderBy  `json:"order_by"`
	Limit   int          `json:"limit"`
}

A SQLExpr can be a proc, an expression inside of a SQL FROM clause, or an expression used as a Zed value generator. Currenly, the "select" keyword collides with the select() generator function (it can be parsed unambiguosly because of the parens but this is not user friendly so we need a new name for select()... see issue #2133). TBD: from alias, "in" over tuples, WITH sub-queries, multi-table FROM implying a JOIN, aliases for tables in FROM and JOIN.

func (*SQLExpr) ExprAST()

func (*SQLExpr) ProcAST()

type SQLFrom ¶

type SQLFrom struct {
	Table Expr `json:"table"`
	Alias Expr `json:"alias"`
}

type SQLJoin ¶

type SQLJoin struct {
	Table    Expr   `json:"table"`
	Style    string `json:"style"`
	LeftKey  Expr   `json:"left_key"`
	RightKey Expr   `json:"right_key"`
	Alias    Expr   `json:"alias"`
}

type SQLOrderBy ¶

type SQLOrderBy struct {
	Kind  string      `json:"kind" unpack:""`
	Keys  []Expr      `json:"keys"`
	Order order.Which `json:"order"`
}

type Search ¶

type Search struct {
	Kind string `json:"kind" unpack:""`
	Expr Expr   `json:"expr"`
}

A proc is a node in the flowgraph that takes records in, processes them, and produces records as output.

func (*Search) ProcAST()

type Sequential ¶

type Sequential struct {
	Kind   string `json:"kind" unpack:""`
	Consts []Def  `json:"consts"`
	Procs  []Proc `json:"procs"`
}

A Sequential proc represents a set of procs that receive a stream of records from their parent into the first proc and each subsequent proc processes the output records from the previous proc.

func (seq *Sequential) Prepend(front Proc)

func (*Sequential) ProcAST()

type SetExpr ¶

type SetExpr struct {
	Kind  string `json:"kind" unpack:""`
	Exprs []Expr `json:"exprs"`
}

func (*SetExpr) ExprAST()

type Shape ¶

type Shape struct {
	Kind string `json:"kind" unpack:""`
}

A proc is a node in the flowgraph that takes records in, processes them, and produces records as output.

func (*Shape) ProcAST()

type Sort ¶

type Sort struct {
	Kind       string      `json:"kind" unpack:""`
	Args       []Expr      `json:"args"`
	Order      order.Which `json:"order"`
	NullsFirst bool        `json:"nullsfirst"`
}

A Sort proc represents a proc that sorts records.

func (*Sort) ProcAST()

type Source ¶

type Source interface {
	Source()
}

type Spread ¶ added in v1.0.0

type Spread struct {
	Kind string `json:"kind" unpack:""`
	Expr Expr   `json:"expr"`
}

type String ¶ added in v1.0.0

type String struct {
	Kind string `json:"kind" unpack:""`
	Text string `json:"text"`
}

func (*String) PatternAST()

type Summarize ¶

type Summarize struct {
	Kind  string       `json:"kind" unpack:""`
	Limit int          `json:"limit"`
	Keys  []Assignment `json:"keys"`
	Aggs  []Assignment `json:"aggs"`
}

A Summarize proc represents a proc that consumes all the records in its input, partitions the records into groups based on the values of the fields specified in the keys field (where the first key is the primary grouping key), and applies aggregators (if any) to each group. The InputSortDir field indicates that input is sorted (with direction indicated by the sign of the field) in the primary grouping key. In this case, the proc outputs the aggregation results from each key as they complete so that large inputs are processed and streamed efficiently. The Limit field specifies the number of different groups that can be aggregated over. When absent, the runtime defaults to an appropriate value. If PartialsOut is true, the proc will produce partial aggregation output result; likewise, if PartialsIn is true, the proc will expect partial results as input.

func (*Summarize) ProcAST()

type Switch ¶

type Switch struct {
	Kind  string `json:"kind" unpack:""`
	Expr  Expr   `json:"expr"`
	Cases []Case `json:"cases"`
}

A Switch proc represents a set of procs that each get a stream of records from their parent.

func (*Switch) ProcAST()

type Tail ¶

type Tail struct {
	Kind  string `json:"kind" unpack:""`
	Count int    `json:"count"`
}

A Tail proc represents a proc that reads all its records from its input transmits the final number of records indicated by the count.

func (*Tail) ProcAST()

type Term ¶ added in v1.0.0

type Term struct {
	Kind  string     `json:"kind" unpack:""`
	Text  string     `json:"text"`
	Value astzed.Any `json:"value"`
}

func (*Term) ExprAST()

type Top ¶

type Top struct {
	Kind  string `json:"kind" unpack:""`
	Limit int    `json:"limit"`
	Args  []Expr `json:"args"`
	Flush bool   `json:"flush"`
}

A Top proc is similar to a Sort with a few key differences: - It only sorts in descending order. - It utilizes a MaxHeap, immediately discarding records that are not in the top N of the sort. - It has an option (Flush) to sort and emit on every batch.

func (*Top) ProcAST()

type Trunk ¶

type Trunk struct {
	Kind   string      `json:"kind" unpack:""`
	Source Source      `json:"source"`
	Seq    *Sequential `json:"seq"`
}

type UnaryExpr ¶

type UnaryExpr struct {
	Kind    string `json:"kind" unpack:""`
	Op      string `json:"op"`
	Operand Expr   `json:"operand"`
}

func (*UnaryExpr) ExprAST()

type Uniq ¶

type Uniq struct {
	Kind  string `json:"kind" unpack:""`
	Cflag bool   `json:"cflag"`
}

A Uniq proc represents a proc that discards any record that matches the previous record transmitted. The Cflag causes the output records to contain a new field called count that contains the number of matched records in that set, similar to the unix shell command uniq.

func (*Uniq) ProcAST()

type Where ¶ added in v1.0.0

type Where struct {
	Kind string `json:"kind" unpack:""`
	Expr Expr   `json:"expr"`
}

A proc is a node in the flowgraph that takes records in, processes them, and produces records as output.

func (*Where) ProcAST()

type Yield ¶ added in v1.0.0

type Yield struct {
	Kind  string `json:"kind" unpack:""`
	Exprs []Expr `json:"exprs"`
}

A proc is a node in the flowgraph that takes records in, processes them, and produces records as output.

func (*Yield) ProcAST()