Method Compile

pkg/filter/filter.go:160–244

Compile parsers the filter expression and builds a binary expression tree where leaf nodes represent constants/variables while internal nodes are operators. Operators can be binary (=) or unary (not). Fields in filter expressions are replaced with respective event parameters via map valuer. For func

()

// Matching the filter involves descending the binary expression tree recursively
// until all nodes are visited.
func (f *filter) Compile() error {
	var err error
	if f.parser.IsSequence() {
		f.seq, err = f.parser.ParseSequence()
	} else {
		f.expr, err = f.parser.ParseExpr()
	}
	if err != nil {
		return err
	}

	// traverse the expression tree
	walk := func(n ql.Node) {
		switch expr := n.(type) {
		case *ql.BinaryExpr:
			if lhs, ok := expr.LHS.(*ql.FieldLiteral); ok {
				f.addField(lhs)
				f.addStringFields(lhs.Field, expr.RHS)
			}
			if rhs, ok := expr.RHS.(*ql.FieldLiteral); ok {
				f.addField(rhs)
				f.addStringFields(rhs.Field, expr.LHS)
			}
			if lhs, ok := expr.LHS.(*ql.BoundFieldLiteral); ok {
				f.addField(lhs.Field)
				f.addBoundField(lhs)
			}
			if rhs, ok := expr.RHS.(*ql.BoundFieldLiteral); ok {
				f.addField(rhs.Field)
				f.addBoundField(rhs)
			}
		case *ql.Function:
			f.hasFunctions = true
			for _, arg := range expr.Args {
				if field, ok := arg.(*ql.FieldLiteral); ok {
					f.addField(field)
				}
				if field, ok := arg.(*ql.BoundFieldLiteral); ok {
					f.addField(field.Field)
					f.addBoundField(field)
				}
				switch exp := arg.(type) {
				case *ql.BinaryExpr:
					if segment, ok := exp.LHS.(*ql.BoundSegmentLiteral); ok {
						f.addSegment(segment)
					}
					if segment, ok := exp.RHS.(*ql.BoundSegmentLiteral); ok {
						f.addSegment(segment)
					}
				}
			}
		case *ql.FieldLiteral:
			if fields.IsBoolean(expr.Field) {
				f.addField(expr)
			}
		}
	}