Method validate

pkg/filter/ql/literal.go:226–279

validate ensures that the function name obtained from the parser exists within the internal functions catalog. It also validates the function signature to make sure required arguments are supplied. Finally, it checks the type of each argument with the expected one.

()

// make sure required arguments are supplied. Finally, it
// checks the type of each argument with the expected one.
func (f *Function) validate() error {
	fn, ok := funcs[strings.ToUpper(f.Name)]
	if !ok {
		return ErrUndefinedFunction(f.Name)
	}

	if len(f.Args) < fn.Desc().RequiredArgs() ||
		len(f.Args) > len(fn.Desc().Args) {
		return ErrFunctionSignature(fn.Desc(), len(f.Args))
	}

	validationFunc := fn.Desc().ArgsValidationFunc
	if validationFunc != nil {
		if err := validationFunc(f.ArgsSlice()); err != nil {
			return err
		}
	}

	for i, expr := range f.Args {
		arg := fn.Desc().Args[i]
		typ := functions.Unknown

		switch reflect.TypeOf(expr) {
		case reflect.TypeOf(&FieldLiteral{}):
			typ = functions.Field
		case reflect.TypeOf(&BoundFieldLiteral{}):
			typ = functions.BoundField
		case reflect.TypeOf(&BoundSegmentLiteral{}):
			typ = functions.BoundSegment
		case reflect.TypeOf(&BareBoundVariableLiteral{}):
			typ = functions.BareBoundVariable
		case reflect.TypeOf(&IPLiteral{}):
			typ = functions.IP
		case reflect.TypeOf(&StringLiteral{}):
			typ = functions.String
		case reflect.TypeOf(&IntegerLiteral{}):
			typ = functions.Number
		case reflect.TypeOf(&Function{}):
			typ = functions.Func
		case reflect.TypeOf(&ListLiteral{}):
			typ = functions.Slice
		case reflect.TypeOf(&BoolLiteral{}):
			typ = functions.Bool
		case reflect.TypeOf(&BinaryExpr{}), reflect.TypeOf(&ParenExpr{}), reflect.TypeOf(&NotExpr{}):
			typ = functions.Expression
		}

		if !arg.ContainsType(typ) {
			return ErrArgumentTypeMismatch(i, arg.Keyword, fn.Name(), arg.Types)
		}
	}

	return nil
}

// SequenceExpr represents a single binary expression within the sequence.
type SequenceExpr struct {