package parse

import "golang.org/x/perf/benchproc/internal/parse"

Package parse implements parsers for golang.org/x/perf/benchproc/syntax.

Currently this package is internal to benchproc, but if we ever migrate perf.golang.org to this expression syntax, it will be valuable to construct database queries from the same grammar.

Index ¶

• type Field
• func ParseProjection(q string) ([]Field, error)
• func (p Field) String() string
• type Filter
• func ParseFilter(q string) (Filter, error)
• type FilterMatch
• func (q *FilterMatch) Match(value []byte) bool
• func (q *FilterMatch) MatchString(value string) bool
• func (q *FilterMatch) String() string
• type FilterOp
• func (q *FilterOp) String() string
• type Op
• type SyntaxError
• func (e *SyntaxError) Error() string

Types ¶

type Field ¶

type Field struct {
	Key string

	// Order is the sort order for this field. This can be
	// "first", meaning to sort by order of first appearance;
	// "fixed", meaning to use the explicit value order in Fixed;
	// or a named sort order.
	Order string

	// Fixed gives the explicit value order for "fixed" ordering.
	// If a record's value is not in this list, the record should
	// be filtered out. Otherwise, values should be sorted
	// according to their order in this list.
	Fixed []string

	// KeyOff and OrderOff give the byte offsets of the key and
	// order, for error reporting.
	KeyOff, OrderOff int
}

A Field is one element in a projection expression. It represents extracting a single dimension of a benchmark result and applying an order to it.

func ParseProjection ¶

func ParseProjection(q string) ([]Field, error)

ParseProjection parses a projection expression into a tuple of Fields.

func (Field) String ¶

func (p Field) String() string

String returns Projection as a valid projection expression.

type Filter ¶

type Filter interface {
	String() string
	// contains filtered or unexported methods
}

A Filter is a node in the boolean filter. It can either be a FilterOp or a FilterMatch.

func ParseFilter ¶

func ParseFilter(q string) (Filter, error)

ParseFilter parses a filter expression into a Filter tree.

type FilterMatch ¶

type FilterMatch struct {
	Key string

	// Regexp is the regular expression to match against the
	// value. This may be nil, in which case this is a literal
	// match against Lit.
	Regexp *regexp.Regexp
	// Lit is the literal value to match against the value if Regexp
	// is nil.
	Lit string

	// Off is the byte offset of the key in the original query,
	// for error reporting.
	Off int
}

A FilterMatch is a leaf in a Filter tree that tests a specific key for a match.

func (*FilterMatch) Match ¶

func (q *FilterMatch) Match(value []byte) bool

Match returns whether q matches the given value of q.Key.

func (*FilterMatch) MatchString ¶

func (q *FilterMatch) MatchString(value string) bool

MatchString returns whether q matches the given value of q.Key.

func (*FilterMatch) String ¶

func (q *FilterMatch) String() string

type FilterOp ¶

type FilterOp struct {
	Op    Op
	Exprs []Filter
}

A FilterOp is a boolean operator in the Filter tree. OpNot must have exactly one child node. OpAnd and OpOr may have zero or more child nodes.

func (*FilterOp) String ¶

func (q *FilterOp) String() string

type Op ¶

type Op int

Op specifies a type of boolean operator.

const (
	OpAnd Op = 1 + iota
	OpOr
	OpNot
)

type SyntaxError ¶

type SyntaxError struct {
	Query string // The original query string
	Off   int    // Byte offset of the error in Query
	Msg   string // Error message
}

A SyntaxError is an error produced by parsing a malformed expression.

func (*SyntaxError) Error ¶

func (e *SyntaxError) Error() string

Source Files ¶

doc.go filter.go projection.go tok.go tree.go