package arango import ( "errors" ) // Operator error. var ( ErrInvalidOperator = errors.New("invalid operator") ErrInvalidOperatorForType = errors.New("invalid operator for type") ) var ( operators = map[string]string{ // Idempotent "==": "==", "!=": "!=", ">": ">", ">=": ">=", "<": "<", "<=": "<=", "IN": "IN", "NOT IN": "NOT IN", "LIKE": "LIKE", "NOT LIKE": "NOT LIKE", // Compatible with Filter.Operator in github.com/annybs/go/qs "eq": "==", "neq": "!=", "gt": ">", "gte": ">=", "lt": "<", "lte": "<=", "in": "IN", "not in": "NOT IN", "like": "LIKE", "not like": "NOT LIKE", } arrayOperators = map[string]bool{"IN": true, "NOT IN": true} boolOperators = map[string]bool{"==": true, "!=": true} numberOperators = map[string]bool{"==": true, "!=": true, ">": true, ">=": true, "<": true, "<=": true} stringOperators = map[string]bool{"==": true, "!=": true, ">": true, ">=": true, "<": true, "<=": true, "LIKE": true, "NOT LIKE": true} ) // IsArrayOperator returns true if the given operator can be used with an array value. func IsArrayOperator(op string) bool { _, err := ParseArrayOperator(op) return err == nil } // IsBoolOperator returns true if the given operator can be used with a Boolean value. func IsBoolOperator(op string) bool { _, err := ParseBoolOperator(op) return err == nil } // IsNumberOperator returns true if the given operator can be used with a numeric value. func IsNumberOperator(op string) bool { _, err := ParseNumberOperator(op) return err == nil } // IsStringOperator returns true if the given operator can be used with a string value. func IsStringOperator(op string) bool { _, err := ParseStringOperator(op) return err == nil } // ParseArrayOperator returns the valid AQL operator for an array operator. // It returns an error if the operator cannot be mapped to AQL or does not support arrays. func ParseArrayOperator(op string) (string, error) { op, err := ParseOperator(op) if err != nil { return op, err } if !arrayOperators[op] { return op, ErrInvalidOperatorForType } return op, nil } // ParseBoolOperator returns the valid AQL operator for a Boolean operator. // It returns an error if the operator cannot be mapped to AQL or does not support Booleans. func ParseBoolOperator(op string) (string, error) { op, err := ParseOperator(op) if err != nil { return op, err } if !boolOperators[op] { return op, ErrInvalidOperatorForType } return op, nil } // ParseNumberOperator returns the valid AQL operator for a numeric operator. // It returns an error if the operator cannot be mapped to AQL or does not support numbers. func ParseNumberOperator(op string) (string, error) { op, err := ParseOperator(op) if err != nil { return op, err } if !numberOperators[op] { return op, ErrInvalidOperatorForType } return op, nil } // ParseOperator returns the valid AQL operator for an arbitrary operator string. // This supports different inputs, such as Filter.Operator in github.com/annybs/go/qs // // If the input operator cannot be mapped to AQL, this function returns ErrInvalidOperator. func ParseOperator(op string) (string, error) { if operators[op] == "" { return "", ErrInvalidOperator } return operators[op], nil } // ParseStringOperator returns the valid AQL operator for a string operator. // It returns an error if the operator cannot be mapped to AQL or does not support strings. func ParseStringOperator(op string) (string, error) { op, err := ParseOperator(op) if err != nil { return op, err } if !stringOperators[op] { return op, ErrInvalidOperatorForType } return op, nil }