predicate

Documentation

Index

• Constants
• Variables
• func Parse(predicate string) (string, error)
• type BinaryExpr
• type ComboExpr
• type ComboItem
• type Expr
• type Field
• type FieldsExpr
• type Ident
• type LiteralExpr
• type LiteralListExpr
• type LiteralType
• type OperatorType
• type ParenExpr
• type Tree
  • func ParseAST(predicate string) (*Tree, error)
  • func (t *Tree) String() string
  • func (t *Tree) Transform()

Constants

const (
	LiteralTypeString = iota
	LiteralTypeBoolean
	LiteralTypeDecimal
	LiteralTypeNull
)

const (
	Unknown = -1
	EOF     = 0
)

const AND = 57361

const BOOLEAN = 57365

const COMMA = 57346

const DOT = 57347

const END = 57352

const EQUAL = 57355

const GREATER = 57353

const IDENT = 57363

const IN = 57359

const INTEGER = 57366

const LBRACK = 57350

const LESS = 57354

const LIKE = 57357

const LPAREN = 57348

const MATCH = 57358

const MINUS = 57360

const NOT = 57356

const NULL = 57367

const OR = 57362

const RBRACK = 57351

const RPAREN = 57349

const STRING = 57364

Variables

var (
	String  = &LiteralType{Type: LiteralTypeString}
	Boolean = &LiteralType{Type: LiteralTypeBoolean}
	Decimal = &LiteralType{Type: LiteralTypeDecimal}
)

var (
	Greater = &OperatorType{Type: GREATER}
	Less    = &OperatorType{Type: LESS}
	Equal   = &OperatorType{Type: EQUAL}
	Not     = &OperatorType{Type: NOT}
	Like    = &OperatorType{Type: LIKE}
	Match   = &OperatorType{Type: MATCH}
	In      = &OperatorType{Type: IN}
	Minus   = &OperatorType{Type: MINUS}
	And     = &OperatorType{Type: AND}
	Or      = &OperatorType{Type: OR}
)

var Null = &LiteralExpr{
	Type:  &LiteralType{Type: LiteralTypeNull},
	Value: "null",
}

Functions

func Parse

func Parse(predicate string) (string, error)

Types

type BinaryExpr

type BinaryExpr struct {
	Op    []*OperatorType
	Left  Expr
	Right Expr
}

type ComboExpr

type ComboExpr struct {
	Items []ComboItem
}

type ComboItem

type ComboItem any

ComboItem will only contain two types, Expr and []*OperatorType, currently, the value of Expr should only be *BinaryExpr

type Expr

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

type Field

type Field any

Field will only contain two types, *Ident and *LiteralType, where the value of *LiteralType must be an integer

type FieldsExpr

type FieldsExpr struct {
	Fields []Field
}

type Ident

type Ident struct {
	Name string
}

type LiteralExpr

type LiteralExpr struct {
	Type  *LiteralType
	Value string
}

type LiteralListExpr

type LiteralListExpr struct {
	List []*LiteralExpr
}

type LiteralType

type LiteralType struct {
	Type int
}

type OperatorType

type OperatorType struct {
	Type int
}

type ParenExpr

type ParenExpr struct {
	Expr Expr
}

type Tree

type Tree struct {
	Expr Expr
}

func ParseAST

func ParseAST(predicate string) (*Tree, error)

func (*Tree) String

func (t *Tree) String() string

func (*Tree) Transform

func (t *Tree) Transform()