Method validate

pkg/traceql/ast_validate.go:198–270

()

}

func (o *BinaryOperation) validate() error {
	if err := o.LHS.validate(); err != nil {
		return err
	}
	if err := o.RHS.validate(); err != nil {
		return err
	}

	lhsT := o.LHS.impliedType()
	rhsT := o.RHS.impliedType()

	if o.Op == OpNotExists || o.Op == OpExists {
		return fmt.Errorf("illegal operation for the given type: %s", o.String())
	}

	if !lhsT.isMatchingOperand(rhsT) {
		return fmt.Errorf("binary operations must operate on the same type: %s", o.String())
	}

	if !o.Op.binaryTypesValid(lhsT, rhsT) {
		return fmt.Errorf("illegal operation for the given types: %s", o.String())
	}

	// if this is a regex operator confirm the RHS is a valid regex
	if o.Op == OpRegex || o.Op == OpNotRegex {
		static, ok := o.RHS.(Static)
		if !ok {
			return fmt.Errorf("invalid type for %s or %s: %s", OpRegex, OpNotRegex, o.RHS.String())
		}

		switch rhsT {
		case TypeString:
			_, err := regexp.Compile(static.EncodeToString(false))
			if err != nil {
				return fmt.Errorf("invalid regex: %s", o.RHS.String())
			}
		case TypeStringArray:
			strs, _ := static.StringArray()
			for _, str := range strs {
				_, err := regexp.Compile(str)
				if err != nil {
					return fmt.Errorf("invalid regex: %s", o.RHS.String())
				}
			}
		default:
			return fmt.Errorf("invalid type for %s or %s: %s", OpRegex, OpNotRegex, o.RHS.String())
		}
	}

	// this condition may not be possible to hit since it's not parseable.
	// however, if we did somehow end up this situation, it would be good to return
	// a reasonable error
	switch o.Op {
	case OpSpansetChild,
		OpSpansetParent,
		OpSpansetDescendant,
		OpSpansetAncestor,
		OpSpansetSibling,