ast

package
v1.15.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 29, 2024 License: BSD-3-Clause Imports: 6 Imported by: 1

Documentation

Overview

Package ast declares the types used to represent syntax trees for Zed queries.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

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 

func (*Agg) ExprAST()

type ArrayExpr 

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

func (*ArrayExpr) ExprAST 

func (*ArrayExpr) ExprAST()

type Assignment 

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

func (*Assignment) ExprAST 

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 

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 operator, 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 

func (*Call) ExprAST()

type Case 

type Case struct {
	Expr Expr `json:"expr"`
	Path Seq  `json:"path"`
}

type Cast 

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

func (*Cast) ExprAST 

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 

func (*Conditional) ExprAST()

type ConstDecl added in v1.4.0 

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

func (*ConstDecl) DeclAST added in v1.4.0 

func (*ConstDecl) DeclAST()

type Cut 

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

An Op is a node in the flowgraph that takes Zed values in, operates upon them, and produces Zed values as output.

func (*Cut) OpAST added in v1.1.0 

func (*Cut) OpAST()

type Decl added in v1.4.0 

type Decl interface {
	DeclAST()
}

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"`
}

An Op is a node in the flowgraph that takes Zed values in, operates upon them, and produces Zed values as output.

func (*Drop) OpAST added in v1.1.0 

func (*Drop) OpAST()

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"`
}

An Op is a node in the flowgraph that takes Zed values in, operates upon them, and produces Zed values as output.

func (*Explode) OpAST added in v1.1.0 

func (*Explode) OpAST()

type Expr 

type Expr interface {
	ExprAST()
}

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    Pattern  `json:"path"`
	Format  string   `json:"format"`
	SortKey *SortKey `json:"sort_key"`
}

func (*File) Source 

func (*File) Source()

type From 

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

An Op is a node in the flowgraph that takes Zed values in, operates upon them, and produces Zed values as output.

func (*From) OpAST added in v1.1.0 

func (*From) OpAST()

type FuncDecl added in v1.4.0 

type FuncDecl struct {
	Kind   string   `json:"kind" unpack:""`
	Name   string   `json:"name"`
	Params []string `json:"params"`
	Expr   Expr     `json:"expr"`
}

func (*FuncDecl) DeclAST added in v1.4.0 

func (*FuncDecl) DeclAST()

type Fuse 

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

An Op is a node in the flowgraph that takes Zed values in, operates upon them, and produces Zed values as output.

func (*Fuse) OpAST added in v1.1.0 

func (*Fuse) OpAST()

type Glob added in v1.0.0 

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

func (*Glob) ExprAST added in v1.0.0 

func (*Glob) ExprAST()

func (*Glob) PatternAST added in v1.0.0 

func (*Glob) PatternAST()

type Grep added in v1.0.0 

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

func (*Grep) ExprAST added in v1.0.0 

func (*Grep) ExprAST()

type HTTP 

type HTTP struct {
	Kind    string      `json:"kind" unpack:""`
	URL     Pattern     `json:"url"`
	Format  string      `json:"format"`
	SortKey *SortKey    `json:"sort_key"`
	Method  string      `json:"method"`
	Headers *RecordExpr `json:"headers"`
	Body    string      `json:"body"`
}

func (*HTTP) Source 

func (*HTTP) Source()
type Head struct {
	Kind  string `json:"kind" unpack:""`
	Count Expr   `json:"count"`
}

An Op is a node in the flowgraph that takes Zed values in, operates upon them, and produces Zed values as output.

func (*Head) OpAST added in v1.1.0 

func (*Head) OpAST()

type ID 

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

func (*ID) ExprAST 

func (*ID) ExprAST()

type Join 

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

An Op is a node in the flowgraph that takes Zed values in, operates upon them, and produces Zed values as output.

func (*Join) OpAST added in v1.1.0 

func (*Join) OpAST()

type Load added in v1.8.0 

type Load struct {
	Kind    string `json:"kind" unpack:""`
	Pool    string `json:"pool"`
	Branch  string `json:"branch"`
	Author  string `json:"author"`
	Message string `json:"message"`
	Meta    string `json:"meta"`
}

An Op is a node in the flowgraph that takes Zed values in, operates upon them, and produces Zed values as output.

func (*Load) OpAST added in v1.8.0 

func (*Load) OpAST()

type MapExpr 

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

func (*MapExpr) ExprAST 

func (*MapExpr) ExprAST()

type Merge added in v1.0.0 

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

An Op is a node in the flowgraph that takes Zed values in, operates upon them, and produces Zed values as output.

func (*Merge) OpAST added in v1.1.0 

func (*Merge) OpAST()

type Op added in v1.1.0 

type Op interface {
	OpAST()
}

Op is the interface implemented by all AST operator nodes.

func Copy 

func Copy(in Op) Op

func UnmarshalOp added in v1.8.0 

func UnmarshalOp(buf []byte) (Op, error)

UnmarshalOp transforms a JSON representation of an operator into an Op.

type OpAssignment 

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

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

func (*OpAssignment) OpAST added in v1.1.0 

func (*OpAssignment) OpAST()

type OpDecl added in v1.9.0 

type OpDecl struct {
	Kind   string   `json:"kind" unpack:""`
	Name   string   `json:"name"`
	Params []string `json:"params"`
	Body   Seq      `json:"body"`
}

func (*OpDecl) DeclAST added in v1.9.0 

func (*OpDecl) DeclAST()

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) OpAST added in v1.1.0 

func (*OpExpr) OpAST()

type Over added in v1.0.0 

type Over struct {
	Kind   string `json:"kind" unpack:""`
	Exprs  []Expr `json:"exprs"`
	Locals []Def  `json:"locals"`
	Body   Seq    `json:"body"`
}

An Op is a node in the flowgraph that takes Zed values in, operates upon them, and produces Zed values as output.

func (*Over) OpAST added in v1.1.0 

func (*Over) OpAST()

type OverExpr added in v1.1.0 

type OverExpr struct {
	Kind   string `json:"kind" unpack:""`
	Locals []Def  `json:"locals"`
	Exprs  []Expr `json:"exprs"`
	Body   Seq    `json:"body"`
}

func (*OverExpr) ExprAST added in v1.1.0 

func (*OverExpr) ExprAST()

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 operator 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"`
	Paths        []Seq      `json:"paths"`
}

A Parallel operator represents a set of operators that each get a stream of Zed values from their parent.

func (*Parallel) OpAST added in v1.1.0 

func (*Parallel) OpAST()

type Pass 

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

An Op is a node in the flowgraph that takes Zed values in, operates upon them, and produces Zed values as output.

func (*Pass) OpAST added in v1.1.0 

func (*Pass) OpAST()

func (*Pass) Source 

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"`
	Delete bool     `json:"delete"`
}

func (*Pool) Source 

func (*Pool) Source()

type PoolSpec 

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

type Put 

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

An Op is a node in the flowgraph that takes Zed values in, operates upon them, and produces Zed values as output.

func (*Put) OpAST added in v1.1.0 

func (*Put) OpAST()

type QuotedString added in v1.9.0 

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

func (*QuotedString) PatternAST added in v1.9.0 

func (*QuotedString) PatternAST()

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 

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 added in v1.0.0 

func (*Regexp) ExprAST()

func (*Regexp) PatternAST added in v1.0.0 

func (*Regexp) PatternAST()

type Rename 

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

An Op is a node in the flowgraph that takes Zed values in, operates upon them, and produces Zed values as output.

func (*Rename) OpAST added in v1.1.0 

func (*Rename) OpAST()

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 an operator, 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) ExprAST()

func (*SQLExpr) OpAST added in v1.1.0 

func (*SQLExpr) OpAST()

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 Sample added in v1.8.0 

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

An Op is a node in the flowgraph that takes Zed values in, operates upon them, and produces Zed values as output.

func (*Sample) OpAST added in v1.8.0 

func (*Sample) OpAST()

type Scope added in v1.8.0 

type Scope struct {
	Kind  string `json:"kind" unpack:""`
	Decls []Decl `json:"decls"`
	Body  Seq    `json:"body"`
}

An Op is a node in the flowgraph that takes Zed values in, operates upon them, and produces Zed values as output.

func (*Scope) OpAST added in v1.8.0 

func (*Scope) OpAST()
type Search struct {
	Kind string `json:"kind" unpack:""`
	Expr Expr   `json:"expr"`
}

An Op is a node in the flowgraph that takes Zed values in, operates upon them, and produces Zed values as output.

func (*Search) OpAST added in v1.1.0 

func (*Search) OpAST()

type Seq added in v1.8.0 

type Seq []Op

A Seq represents a sequence of operators that receive a stream of Zed values from their parent into the first operator and each subsequent operator processes the output records from the previous operator.

func CopySeq added in v1.8.0 

func CopySeq(in Seq) Seq

func UnmarshalObject added in v1.8.0 

func UnmarshalObject(anon interface{}) (Seq, error)

func (*Seq) Prepend added in v1.8.0 

func (seq *Seq) Prepend(front Op)

type SetExpr 

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

func (*SetExpr) ExprAST 

func (*SetExpr) ExprAST()

type Shape 

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

An Op is a node in the flowgraph that takes Zed values in, operates upon them, and produces Zed values as output.

func (*Shape) OpAST added in v1.1.0 

func (*Shape) OpAST()

type Sort 

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

An Op is a node in the flowgraph that takes Zed values in, operates upon them, and produces Zed values as output.

func (*Sort) OpAST added in v1.1.0 

func (*Sort) OpAST()

type SortKey added in v1.8.0 

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

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 added in v1.0.0 

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"`
}

An Op is a node in the flowgraph that takes Zed values in, operates upon them, and produces Zed values as output.

func (*Summarize) OpAST added in v1.1.0 

func (*Summarize) OpAST()

type Switch 

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

An Op is a node in the flowgraph that takes Zed values in, operates upon them, and produces Zed values as output.

func (*Switch) OpAST added in v1.1.0 

func (*Switch) OpAST()

type Tail 

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

An Op is a node in the flowgraph that takes Zed values in, operates upon them, and produces Zed values as output.

func (*Tail) OpAST added in v1.1.0 

func (*Tail) OpAST()

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 added in v1.0.0 

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"`
}

An Op is a node in the flowgraph that takes Zed values in, operates upon them, and produces Zed values as output.

func (*Top) OpAST added in v1.1.0 

func (*Top) OpAST()

type Trunk 

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

type UnaryExpr 

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

func (*UnaryExpr) ExprAST 

func (*UnaryExpr) ExprAST()

type Uniq 

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

An Op is a node in the flowgraph that takes Zed values in, operates upon them, and produces Zed values as output.

func (*Uniq) OpAST added in v1.1.0 

func (*Uniq) OpAST()

type VectorElem added in v1.2.0 

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

type VectorValue added in v1.2.0 

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

type Where added in v1.0.0 

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

An Op is a node in the flowgraph that takes Zed values in, operates upon them, and produces Zed values as output.

func (*Where) OpAST added in v1.1.0 

func (*Where) OpAST()

type Yield added in v1.0.0 

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

An Op is a node in the flowgraph that takes Zed values in, operates upon them, and produces Zed values as output.

func (*Yield) OpAST added in v1.1.0 

func (*Yield) OpAST()

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.