Method evalBoundSequence

pkg/filter/filter.go:256–337

evalBoundSequence evaluates the sequence with bound fields and returns true if the sequence expression matches or false otherwise.

(
	e *event.Event,
	seqID int,
	expr *ql.SequenceExpr,
	partials map[int][]*event.Event,
	valuer ql.MapValuer,
)

// and returns true if the sequence expression matches or false
// otherwise.
func (f *filter) evalBoundSequence(
	e *event.Event,
	seqID int,
	expr *ql.SequenceExpr,
	partials map[int][]*event.Event,
	valuer ql.MapValuer,
) bool {
	//  map all partials to their sequence aliases
	maxSlots := len(partials[seqID])
	aliasEvents := make(map[string][]*event.Event, seqID)
	for i := range seqID {
		alias := f.seq.Expressions[i].Alias
		if alias == "" {
			continue
		}
		aliasEvents[alias] = partials[i]
		if l := len(partials[i]); l > maxSlots {
			maxSlots = l
		}
	}

	// retrieve or compute bound fields for this sequence expression
	flds, ok := f.seqBoundFields[seqID]
	if !ok {
		flds = f.addSeqBoundFields(seqID, expr.BoundFields)
	}

	// iterate slot-by-slot across all bound aliases
	for slot := 0; slot < maxSlots; slot++ {
		// process each bound field in this sequence expression
		var evt *event.Event
		for _, fld := range flds {
			evts := aliasEvents[fld.BoundVar]
			switch {
			case len(evts) == 0:
				continue
			case slot >= len(evts):
				// pick the latest event if all
				// events for this slot are consumed
				evt = evts[len(evts)-1]
			default:
				evt = evts[slot]
			}

			// extract bound variable value
			accessor := fld.Accessor(f)
			if accessor == nil {
				continue
			}
			v, err := accessor.Get(fld.Field, evt)
			if v == nil || err != nil {
				if v == nil {
					valuer[fld.Value] = defaultAccessorValue(fld.Field)
				}
				if err != nil && !errs.IsParamNotFound(err) {
					valuer[fld.Value] = defaultAccessorValue(fld.Field)
					accessorErrors.Add(err.Error(), 1)
				}