filter

Documentation

Index

• Variables
• func InternalError(err error) error
• func UnknownFunction(name string) error
• func UnknownName(name string) error
• type AndExpr
• type FilterExpr
• type InTableExpr
• type IsNullExpr
• type Name
• type NameKind
• type OpExpr
• type OpKind
• type OrExpr
• type Resolver
  • func New(adpater ResolverAdapter) *Resolver
  • func (r *Resolver) InTable(name, typ string, args []ast.Expr) (*InTableExpr, error)
  • func (r *Resolver) Resolve(e ast.Expr) (FilterExpr, error)
  • func (r *Resolver) ResolveSort(e SortExpr) (SortExpr, error)
  • func (r *Resolver) ResolveToIdent(e ast.Expr) (string, error)
  • func (r *Resolver) ResolveToNumber(e ast.Expr) (int64, error)
  • func (r *Resolver) ResolveToStr(e ast.Expr) (string, error)
• type ResolverAdapter
• type SortExpr
  • func ParseSort(s string) (SortExpr, error)
• type SortExprDefault
• type SortExprRandom
• type SortExprSort
• type SortItem
• type SortType
• type Table

Variables

var ErrInternalError = errors.New("internal error")

var ErrUnknownFunction = errors.New("unknown function")

var ErrUnknownName = errors.New("unknown name")

Functions

func InternalError

func InternalError(err error) error

func UnknownFunction

func UnknownFunction(name string) error

func UnknownName

func UnknownName(name string) error

Types

type AndExpr

type AndExpr struct {
	Left  FilterExpr
	Right FilterExpr
}

type FilterExpr

type FilterExpr interface {
	// contains filtered or unexported methods
}

type InTableExpr

type InTableExpr struct {
	Not   bool
	Table Table
	Ids   []string
}

type IsNullExpr

type IsNullExpr struct {
	Name string
	Not  bool
}

type Name

type Name struct {
	Kind     NameKind
	Name     string
	Nullable bool
}

type NameKind

type NameKind int

const (
	NameKindString NameKind = iota
	NameKindNumber
)

type OpExpr

type OpExpr struct {
	Kind  OpKind
	Name  string
	Value any
}

type OpKind

type OpKind int

const (
	OpEqual OpKind = iota
	OpNotEqual
	OpLike
	OpGreater
	OpGreaterEqual
	OpLesser
	OpLesserEqual
)

type OrExpr

type OrExpr struct {
	Left  FilterExpr
	Right FilterExpr
}

type Resolver

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

func New

func New(adpater ResolverAdapter) *Resolver

func (*Resolver) InTable

func (r *Resolver) InTable(name, typ string, args []ast.Expr) (*InTableExpr, error)

func (*Resolver) Resolve

func (r *Resolver) Resolve(e ast.Expr) (FilterExpr, error)

func (*Resolver) ResolveSort

func (r *Resolver) ResolveSort(e SortExpr) (SortExpr, error)

func (*Resolver) ResolveToIdent

func (r *Resolver) ResolveToIdent(e ast.Expr) (string, error)

func (*Resolver) ResolveToNumber

func (r *Resolver) ResolveToNumber(e ast.Expr) (int64, error)

func (*Resolver) ResolveToStr

func (r *Resolver) ResolveToStr(e ast.Expr) (string, error)

type ResolverAdapter

type ResolverAdapter interface {
	ResolveNameToId(typ, name string) (string, bool)
	ResolveVariableName(name string) (Name, bool)
	ResolveTable(typ string) (Table, bool)

	ResolveFunctionCall(resolver *Resolver, name string, args []ast.Expr) (FilterExpr, error)

	DefaultSort() (string, SortType)
}

type SortExpr

type SortExpr interface {
	// contains filtered or unexported methods
}

func ParseSort

func ParseSort(s string) (SortExpr, error)

type SortExprDefault

type SortExprDefault struct{}

type SortExprRandom

type SortExprRandom struct{}

type SortExprSort

type SortExprSort struct {
	Items []SortItem
}

type SortItem

type SortItem struct {
	Type SortType
	Name string
}

type SortType

type SortType int

const (
	SortTypeAsc SortType = iota
	SortTypeDesc
)

type Table

type Table struct {
	Name       string
	SelectName string
	WhereName  string
}