filter

Documentation

Index

• Constants
• Variables
• func FilterErrorMessage(state, lookAhead int) string
• func FilterParse(Filterlex FilterLexer) int
• func FilterStatname(s int) string
• func FilterTokname(c int) string
• func Filterlex1(lex FilterLexer, lval *FilterSymType) (char, token int)
• func NewNullVal() nullVal
• type AndExpr
  • func (e AndExpr) Eval(v interface{}) (interface{}, error)
  • func (e AndExpr) Traverse(accept func(Expr) bool, visit func(Expr))
• type BoolVal
  • func (e BoolVal) Eval(interface{}) (interface{}, error)
  • func (e BoolVal) Traverse(accept func(e Expr) bool, visit func(e Expr))
• type ComparisonExpr
  • func (e ComparisonExpr) Eval(v interface{}) (interface{}, error)
  • func (e ComparisonExpr) Traverse(accept func(e Expr) bool, visit func(e Expr))
• type Expr
  • func NewAndExpr(left, right Expr) Expr
  • func NewComparisonExpr(left Expr, operator string, right Expr) Expr
  • func NewIsNullExpr(expr Expr, operator string) Expr
  • func NewNotExpr(e Expr) Expr
  • func NewOrExpr(left, right Expr) Expr
  • func ParseFilterExpression(s string) (Expr, error)
• type FilterLexer
• type FilterParser
  • func FilterNewParser() FilterParser
• type FilterParserImpl
  • func (p *FilterParserImpl) Lookahead() int
  • func (Filterrcvr *FilterParserImpl) Parse(Filterlex FilterLexer) int
• type FilterSymType
• type FloatVal
  • func (e FloatVal) Eval(interface{}) (interface{}, error)
  • func (e FloatVal) Traverse(accept func(e Expr) bool, visit func(e Expr))
• type IntVal
  • func (e IntVal) Eval(interface{}) (interface{}, error)
  • func (e IntVal) Traverse(accept func(e Expr) bool, visit func(e Expr))
• type IsNullExpr
  • func (e IsNullExpr) Eval(v interface{}) (interface{}, error)
  • func (e IsNullExpr) Traverse(accept func(e Expr) bool, visit func(e Expr))
• type JSONPathVal
  • func NewJSONPathVal(jsonPath *jsonpath.JSONPath, pathExpr string) JSONPathVal
  • func (e JSONPathVal) Eval(v interface{}) (interface{}, error)
  • func (e JSONPathVal) Traverse(accept func(e Expr) bool, visit func(e Expr))
• type NotExpr
  • func (e NotExpr) Eval(v interface{}) (interface{}, error)
  • func (e NotExpr) Traverse(accept func(e Expr) bool, visit func(e Expr))
• type OrExpr
  • func (e OrExpr) Eval(v interface{}) (interface{}, error)
  • func (e OrExpr) Traverse(accept func(e Expr) bool, visit func(e Expr))
• type Order
  • func NewOrder(expr Expr, dir string) *Order
• type OrderBy
  • func NewEmptyOrderBy() OrderBy
  • func NewOrderBy(order *Order) OrderBy
  • func ParseOrderByExpression(s string) (OrderBy, error)
  • func (o OrderBy) Sort(slice interface{}) error
• type StringVal
  • func (e StringVal) Eval(interface{}) (interface{}, error)
  • func (e StringVal) Traverse(accept func(e Expr) bool, visit func(e Expr))

Constants

const (
	EqualStr        = "="
	LessThanStr     = "<"
	GreaterThanStr  = ">"
	LessEqualStr    = "<="
	GreaterEqualStr = ">="
	NotEqualStr     = "!="
	LikeStr         = "like"
	NotLikeStr      = "not like"
	IsNull          = "is null"
	IsNotNull       = "is not null"
)

const (
	AscScr  = "asc"
	DescScr = "desc"
)

Order.Direction

const AND = 57347

const ASC = 57362

const DESC = 57363

const FALSE = 57360

const FLOAT = 57356

const FilterEofCode = 1

const FilterErrCode = 2

const FilterFlag = -1000

const FilterInitialStackSize = 16

const FilterLast = 64

const FilterPrivate = 57344

const GE = 57350

const INTEGRAL = 57355

const IS = 57353

const JSON_PATH = 57357

const LE = 57349

const LIKE = 57352

const MaxInt = uint64(int(MaxUint >> 1))

const MaxUint = ^uint(0)

const NE = 57351

const NOT = 57348

const NULL = 57358

const OR = 57346

const START_EXPRESSION = 57361

const START_ORDER_LIST = 57364

const STRING = 57354

const TRUE = 57359

Variables

var (
	FilterDebug        = 0
	FilterErrorVerbose = false
)

var FilterAct = [...]int{

	8, 19, 9, 7, 13, 14, 15, 16, 17, 10,
	11, 35, 6, 50, 13, 14, 15, 16, 17, 10,
	11, 37, 38, 20, 45, 47, 43, 43, 42, 44,
	2, 4, 22, 21, 3, 22, 21, 48, 23, 24,
	46, 21, 1, 36, 41, 18, 43, 12, 49, 25,
	5, 0, 0, 39, 40, 27, 29, 30, 31, 32,
	33, 34, 26, 28,
}

var FilterChk = [...]int{

	-1000, -10, 24, 28, -1, -2, 15, 6, -6, -5,
	22, 23, -4, 17, 18, 19, 20, 21, -7, -8,
	20, 5, 4, -1, -1, -3, 13, 6, 14, 7,
	8, 9, 10, 11, 12, 27, -9, 25, 26, -1,
	-1, 16, -5, -6, -5, 13, 21, 6, -8, -5,
	21,
}

var FilterDef = [...]int{

	0, -2, 0, 29, 1, 3, 0, 0, -2, 0,
	27, 28, 14, 22, 23, 24, 25, 26, 2, 30,
	33, 0, 0, 0, 7, 0, 0, 0, 0, 16,
	17, 18, 19, 20, 21, 0, 32, 34, 35, 5,
	6, 4, 9, 15, 10, 0, 12, 0, 31, 11,
	13,
}

var FilterErrorMessages = [...]struct {
	state int
	token int
	msg   string
}{}

var FilterExca = [...]int{
	-1, 1,
	1, -1,
	-2, 0,
	-1, 8,
	1, 8,
	4, 8,
	5, 8,
	16, 8,
	-2, 15,
}

var FilterPact = [...]int{

	6, -1000, -3, 3, 31, -1000, -3, -3, -1000, 49,
	-1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -16, -1000,
	-4, -3, -3, 28, -1000, -13, -13, 11, 19, -1000,
	-1000, -1000, -1000, -1000, -1000, 3, -1000, -1000, -1000, -1000,
	36, -1000, -1000, -1000, -1000, -13, -1000, -8, -1000, -1000,
	-1000,
}

var FilterPgo = [...]int{

	0, 31, 50, 49, 47, 2, 0, 45, 1, 43,
	42,
}

var FilterR1 = [...]int{

	0, 10, 10, 1, 1, 1, 1, 1, 1, 2,
	2, 2, 2, 2, 5, 5, 3, 3, 3, 3,
	3, 3, 4, 4, 4, 4, 4, 6, 6, 7,
	7, 7, 8, 9, 9, 9,
}

var FilterR2 = [...]int{

	0, 2, 2, 1, 3, 3, 3, 2, 1, 3,
	3, 4, 3, 4, 1, 1, 1, 1, 1, 1,
	1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
	1, 3, 2, 0, 1, 1,
}

var FilterStatenames = [...]string{}

var FilterTok1 = [...]int{

	1, 3, 3, 3, 3, 3, 3, 3, 3, 3,
	3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
	3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
	3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
	15, 16, 3, 3, 27, 3, 3, 3, 3, 3,
	3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
	8, 7, 9,
}

var FilterTok2 = [...]int{

	2, 3, 4, 5, 6, 10, 11, 12, 13, 14,
	17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
	28,
}

var FilterTok3 = [...]int{
	0,
}

var FilterToknames = [...]string{
	"$end",
	"error",
	"$unk",
	"OR",
	"AND",
	"NOT",
	"'='",
	"'<'",
	"'>'",
	"LE",
	"GE",
	"NE",
	"LIKE",
	"IS",
	"'('",
	"')'",
	"STRING",
	"INTEGRAL",
	"FLOAT",
	"JSON_PATH",
	"NULL",
	"TRUE",
	"FALSE",
	"START_EXPRESSION",
	"ASC",
	"DESC",
	"','",
	"START_ORDER_LIST",
}

Functions

func FilterErrorMessage

func FilterErrorMessage(state, lookAhead int) string

func FilterParse

func FilterParse(Filterlex FilterLexer) int

func FilterStatname

func FilterStatname(s int) string

func FilterTokname

func FilterTokname(c int) string

func Filterlex1

func Filterlex1(lex FilterLexer, lval *FilterSymType) (char, token int)

func NewNullVal

func NewNullVal() nullVal

Types

type AndExpr

type AndExpr struct {
	Left, Right Expr
}

func (AndExpr) Eval

func (e AndExpr) Eval(v interface{}) (interface{}, error)

func (AndExpr) Traverse

func (e AndExpr) Traverse(accept func(Expr) bool, visit func(Expr))

type BoolVal

type BoolVal bool

func (BoolVal) Eval

func (e BoolVal) Eval(interface{}) (interface{}, error)

func (BoolVal) Traverse

func (e BoolVal) Traverse(accept func(e Expr) bool, visit func(e Expr))

type ComparisonExpr

type ComparisonExpr struct {
	Operator    string
	Left, Right Expr
}

func (ComparisonExpr) Eval

func (e ComparisonExpr) Eval(v interface{}) (interface{}, error)

func (ComparisonExpr) Traverse

func (e ComparisonExpr) Traverse(accept func(e Expr) bool, visit func(e Expr))

type Expr

type Expr interface {
	Eval(interface{}) (interface{}, error)
	Traverse(accept func(a Expr) bool, visit func(v Expr))
}

func NewAndExpr

func NewAndExpr(left, right Expr) Expr

func NewComparisonExpr

func NewComparisonExpr(left Expr, operator string, right Expr) Expr

func NewIsNullExpr

func NewIsNullExpr(expr Expr, operator string) Expr

func NewNotExpr

func NewNotExpr(e Expr) Expr

func NewOrExpr

func NewOrExpr(left, right Expr) Expr

func ParseFilterExpression

func ParseFilterExpression(s string) (Expr, error)

type FilterLexer

type FilterLexer interface {
	Lex(lval *FilterSymType) int
	Error(s string)
}

type FilterParser

type FilterParser interface {
	Parse(FilterLexer) int
	Lookahead() int
}

func FilterNewParser

func FilterNewParser() FilterParser

type FilterParserImpl

type FilterParserImpl struct {
	// contains filtered or unexported fields
}

func (*FilterParserImpl) Lookahead

func (p *FilterParserImpl) Lookahead() int

func (*FilterParserImpl) Parse

func (Filterrcvr *FilterParserImpl) Parse(Filterlex FilterLexer) int

type FilterSymType

type FilterSymType struct {
	// contains filtered or unexported fields
}

type FloatVal

type FloatVal float64

func (FloatVal) Eval

func (e FloatVal) Eval(interface{}) (interface{}, error)

func (FloatVal) Traverse

func (e FloatVal) Traverse(accept func(e Expr) bool, visit func(e Expr))

type IntVal

type IntVal int

func (IntVal) Eval

func (e IntVal) Eval(interface{}) (interface{}, error)

func (IntVal) Traverse

func (e IntVal) Traverse(accept func(e Expr) bool, visit func(e Expr))

type IsNullExpr

type IsNullExpr struct {
	Operator string
	Expr     Expr
}

func (IsNullExpr) Eval

func (e IsNullExpr) Eval(v interface{}) (interface{}, error)

func (IsNullExpr) Traverse

func (e IsNullExpr) Traverse(accept func(e Expr) bool, visit func(e Expr))

type JSONPathVal

type JSONPathVal struct {
	JSONPath     *jsonpath.JSONPath
	JSONPathExpr string
}

func NewJSONPathVal

func NewJSONPathVal(jsonPath *jsonpath.JSONPath, pathExpr string) JSONPathVal

func (JSONPathVal) Eval

func (e JSONPathVal) Eval(v interface{}) (interface{}, error)

func (JSONPathVal) Traverse

func (e JSONPathVal) Traverse(accept func(e Expr) bool, visit func(e Expr))

type NotExpr

type NotExpr struct {
	Expr Expr
}

func (NotExpr) Eval

func (e NotExpr) Eval(v interface{}) (interface{}, error)

func (NotExpr) Traverse

func (e NotExpr) Traverse(accept func(e Expr) bool, visit func(e Expr))

type OrExpr

type OrExpr struct {
	Left, Right Expr
}

func (OrExpr) Eval

func (e OrExpr) Eval(v interface{}) (interface{}, error)

func (OrExpr) Traverse

func (e OrExpr) Traverse(accept func(e Expr) bool, visit func(e Expr))

type Order

type Order struct {
	Expr      Expr
	Direction string
}

func NewOrder

func NewOrder(expr Expr, dir string) *Order

type OrderBy

type OrderBy []*Order

func NewEmptyOrderBy

func NewEmptyOrderBy() OrderBy

func NewOrderBy

func NewOrderBy(order *Order) OrderBy

func ParseOrderByExpression

func ParseOrderByExpression(s string) (OrderBy, error)

func (OrderBy) Sort

func (o OrderBy) Sort(slice interface{}) error

type StringVal

type StringVal string

func (StringVal) Eval

func (e StringVal) Eval(interface{}) (interface{}, error)

func (StringVal) Traverse

func (e StringVal) Traverse(accept func(e Expr) bool, visit func(e Expr))