query

Documentation

Index

• Variables
• func EvaluateOperation(operator OperatorType, fieldType string, a, b any) (bool, error)
• type Filter
• type FilterType
• type Filters
• type OperatorType
• type Order
• type OrderType
• type Query
  • func NewQuery() *Query
  • func (x *Query) AddOrder(orderType OrderType, field int) *Query
  • func (x *Query) SetFilters(opType FilterType, filters []Filter) *Query
  • func (x *Query) SetLimit(limit int) *Query
  • func (x *Query) SetOrders(orders []Order) *Query

Variables

var BoolOperations = map[OperatorType]func(a, b bool) bool{
	OperatorTypeEqual:    func(a, b bool) bool { return a == b },
	OperatorTypeNotEqual: func(a, b bool) bool { return a != b },
}

var Float32Operations = map[OperatorType]func(a, b float32) bool{
	OperatorTypeEqual:    func(a, b float32) bool { return a == b },
	OperatorTypeNotEqual: func(a, b float32) bool { return a != b },

	OperatorTypeGreaterThan:      func(a, b float32) bool { return a > b },
	OperatorTypeLessThan:         func(a, b float32) bool { return a < b },
	OperatorTypeGreaterThanEqual: func(a, b float32) bool { return a >= b },
	OperatorTypeLessThanEqual:    func(a, b float32) bool { return a <= b },
}

var Float64Operations = map[OperatorType]func(a, b float64) bool{
	OperatorTypeEqual:    func(a, b float64) bool { return a == b },
	OperatorTypeNotEqual: func(a, b float64) bool { return a != b },

	OperatorTypeGreaterThan:      func(a, b float64) bool { return a > b },
	OperatorTypeLessThan:         func(a, b float64) bool { return a < b },
	OperatorTypeGreaterThanEqual: func(a, b float64) bool { return a >= b },
	OperatorTypeLessThanEqual:    func(a, b float64) bool { return a <= b },
}

var Int16Operations = map[OperatorType]func(a, b int16) bool{
	OperatorTypeEqual:    func(a, b int16) bool { return a == b },
	OperatorTypeNotEqual: func(a, b int16) bool { return a != b },

	OperatorTypeGreaterThan:      func(a, b int16) bool { return a > b },
	OperatorTypeLessThan:         func(a, b int16) bool { return a < b },
	OperatorTypeGreaterThanEqual: func(a, b int16) bool { return a >= b },
	OperatorTypeLessThanEqual:    func(a, b int16) bool { return a <= b },
}

var Int32Operations = map[OperatorType]func(a, b int32) bool{
	OperatorTypeEqual:    func(a, b int32) bool { return a == b },
	OperatorTypeNotEqual: func(a, b int32) bool { return a != b },

	OperatorTypeGreaterThan:      func(a, b int32) bool { return a > b },
	OperatorTypeLessThan:         func(a, b int32) bool { return a < b },
	OperatorTypeGreaterThanEqual: func(a, b int32) bool { return a >= b },
	OperatorTypeLessThanEqual:    func(a, b int32) bool { return a <= b },
}

var Int64Operations = map[OperatorType]func(a, b int64) bool{
	OperatorTypeEqual:    func(a, b int64) bool { return a == b },
	OperatorTypeNotEqual: func(a, b int64) bool { return a != b },

	OperatorTypeGreaterThan:      func(a, b int64) bool { return a > b },
	OperatorTypeLessThan:         func(a, b int64) bool { return a < b },
	OperatorTypeGreaterThanEqual: func(a, b int64) bool { return a >= b },
	OperatorTypeLessThanEqual:    func(a, b int64) bool { return a <= b },
}

var Int8Operations = map[OperatorType]func(a, b int8) bool{
	OperatorTypeEqual:    func(a, b int8) bool { return a == b },
	OperatorTypeNotEqual: func(a, b int8) bool { return a != b },

	OperatorTypeGreaterThan:      func(a, b int8) bool { return a > b },
	OperatorTypeLessThan:         func(a, b int8) bool { return a < b },
	OperatorTypeGreaterThanEqual: func(a, b int8) bool { return a >= b },
	OperatorTypeLessThanEqual:    func(a, b int8) bool { return a <= b },
}

var IntOperations = map[OperatorType]func(a, b int) bool{
	OperatorTypeEqual:    func(a, b int) bool { return a == b },
	OperatorTypeNotEqual: func(a, b int) bool { return a != b },

	OperatorTypeGreaterThan:      func(a, b int) bool { return a > b },
	OperatorTypeLessThan:         func(a, b int) bool { return a < b },
	OperatorTypeGreaterThanEqual: func(a, b int) bool { return a >= b },
	OperatorTypeLessThanEqual:    func(a, b int) bool { return a <= b },
}

var OperatorsRegistry = map[string]any{
	"string": StringOperations,

	"bool": BoolOperations,

	"int":   IntOperations,
	"int8":  Int8Operations,
	"int16": Int16Operations,
	"int32": Int32Operations,
	"int64": Int64Operations,

	"uint":   UintOperations,
	"uint8":  Uint8Operations,
	"uint16": Uint16Operations,
	"uint32": Uint32Operations,
	"uint64": Uint64Operations,

	"float32": Float32Operations,
	"float64": Float64Operations,

	"uuid.UUID": UuidOperations,

	"time.Time": TimeOperations,
}

var StringOperations = map[OperatorType]func(a, b string) bool{
	OperatorTypeEqual:       func(a, b string) bool { return a == b },
	OperatorTypeNotEqual:    func(a, b string) bool { return a != b },
	OperatorTypeContains:    func(a, b string) bool { return strings.Contains(a, b) },
	OperatorTypeNotContains: func(a, b string) bool { return !strings.Contains(a, b) },
	OperatorTypeStartsWith:  func(a, b string) bool { return strings.HasPrefix(a, b) },
	OperatorTypeEndsWith:    func(a, b string) bool { return strings.HasSuffix(a, b) },

	OperatorTypeGreaterThan:      func(a, b string) bool { return a > b },
	OperatorTypeLessThan:         func(a, b string) bool { return a < b },
	OperatorTypeGreaterThanEqual: func(a, b string) bool { return a >= b },
	OperatorTypeLessThanEqual:    func(a, b string) bool { return a <= b },
}

var TimeOperations = map[OperatorType]func(a, b time.Time) bool{
	OperatorTypeEqual:    func(a, b time.Time) bool { return a.Equal(b) },
	OperatorTypeNotEqual: func(a, b time.Time) bool { return !a.Equal(b) },

	OperatorTypeGreaterThan:      func(a, b time.Time) bool { return a.After(b) },
	OperatorTypeLessThan:         func(a, b time.Time) bool { return a.Before(b) },
	OperatorTypeGreaterThanEqual: func(a, b time.Time) bool { return a.After(b) || a.Equal(b) },
	OperatorTypeLessThanEqual:    func(a, b time.Time) bool { return a.Before(b) || a.Equal(b) },
}

var Uint16Operations = map[OperatorType]func(a, b uint16) bool{
	OperatorTypeEqual:    func(a, b uint16) bool { return a == b },
	OperatorTypeNotEqual: func(a, b uint16) bool { return a != b },

	OperatorTypeGreaterThan:      func(a, b uint16) bool { return a > b },
	OperatorTypeLessThan:         func(a, b uint16) bool { return a < b },
	OperatorTypeGreaterThanEqual: func(a, b uint16) bool { return a >= b },
	OperatorTypeLessThanEqual:    func(a, b uint16) bool { return a <= b },
}

var Uint32Operations = map[OperatorType]func(a, b uint32) bool{
	OperatorTypeEqual:    func(a, b uint32) bool { return a == b },
	OperatorTypeNotEqual: func(a, b uint32) bool { return a != b },

	OperatorTypeGreaterThan:      func(a, b uint32) bool { return a > b },
	OperatorTypeLessThan:         func(a, b uint32) bool { return a < b },
	OperatorTypeGreaterThanEqual: func(a, b uint32) bool { return a >= b },
	OperatorTypeLessThanEqual:    func(a, b uint32) bool { return a <= b },
}

var Uint64Operations = map[OperatorType]func(a, b uint64) bool{
	OperatorTypeEqual:    func(a, b uint64) bool { return a == b },
	OperatorTypeNotEqual: func(a, b uint64) bool { return a != b },

	OperatorTypeGreaterThan:      func(a, b uint64) bool { return a > b },
	OperatorTypeLessThan:         func(a, b uint64) bool { return a < b },
	OperatorTypeGreaterThanEqual: func(a, b uint64) bool { return a >= b },
	OperatorTypeLessThanEqual:    func(a, b uint64) bool { return a <= b },
}

var Uint8Operations = map[OperatorType]func(a, b uint8) bool{
	OperatorTypeEqual:    func(a, b uint8) bool { return a == b },
	OperatorTypeNotEqual: func(a, b uint8) bool { return a != b },

	OperatorTypeGreaterThan:      func(a, b uint8) bool { return a > b },
	OperatorTypeLessThan:         func(a, b uint8) bool { return a < b },
	OperatorTypeGreaterThanEqual: func(a, b uint8) bool { return a >= b },
	OperatorTypeLessThanEqual:    func(a, b uint8) bool { return a <= b },
}

var UintOperations = map[OperatorType]func(a, b uint) bool{
	OperatorTypeEqual:    func(a, b uint) bool { return a == b },
	OperatorTypeNotEqual: func(a, b uint) bool { return a != b },

	OperatorTypeGreaterThan:      func(a, b uint) bool { return a > b },
	OperatorTypeLessThan:         func(a, b uint) bool { return a < b },
	OperatorTypeGreaterThanEqual: func(a, b uint) bool { return a >= b },
	OperatorTypeLessThanEqual:    func(a, b uint) bool { return a <= b },
}

var UuidOperations = map[OperatorType]func(a, b uuid.UUID) bool{
	OperatorTypeEqual:    func(a, b uuid.UUID) bool { return a == b },
	OperatorTypeNotEqual: func(a, b uuid.UUID) bool { return a != b },
}

Functions

func EvaluateOperation

func EvaluateOperation(operator OperatorType, fieldType string, a, b any) (bool, error)

Types

type Filter

type Filter struct {
	Field int
	Value any
	Op    OperatorType
}

type FilterType

type FilterType int

const (
	FilterTypeUndefined FilterType = iota
	FilterTypeOr
	FilterTypeAnd
)

type Filters

type Filters struct {
	Type    FilterType
	Filters []Filter
}

type OperatorType

type OperatorType int

const (
	OperatorTypeUndefined OperatorType = iota

	OperatorTypeEqual
	OperatorTypeNotEqual
	OperatorTypeGreaterThan
	OperatorTypeGreaterThanEqual
	OperatorTypeLessThan
	OperatorTypeLessThanEqual
	OperatorTypeContains
	OperatorTypeNotContains
	OperatorTypeStartsWith
	OperatorTypeEndsWith
)

type Order

type Order struct {
	Type  OrderType
	Field int
}

type OrderType

type OrderType int

const (
	OrderTypeUndefined OrderType = iota
	OrderTypeAsc
	OrderTypeDesc
)

type Query

type Query struct {
	Filters Filters
	Orders  []Order
	Limit   int
}

func NewQuery

func NewQuery() *Query

func (*Query) AddOrder

func (x *Query) AddOrder(orderType OrderType, field int) *Query

func (*Query) SetFilters

func (x *Query) SetFilters(opType FilterType, filters []Filter) *Query

func (*Query) SetLimit

func (x *Query) SetLimit(limit int) *Query

func (*Query) SetOrders

func (x *Query) SetOrders(orders []Order) *Query