super-graph/qcode/qcode.go

1091 lines
19 KiB
Go
Raw Normal View History

2019-03-24 14:57:29 +01:00
package qcode
import (
2019-04-21 01:42:08 +02:00
"errors"
2019-03-24 14:57:29 +01:00
"fmt"
2019-10-14 08:51:36 +02:00
"strconv"
2019-03-24 14:57:29 +01:00
"strings"
"sync"
2019-03-24 14:57:29 +01:00
"github.com/dosco/super-graph/util"
2019-03-25 05:43:14 +01:00
"github.com/gobuffalo/flect"
2019-03-24 14:57:29 +01:00
)
2019-09-05 06:09:56 +02:00
type QType int
2019-09-06 06:34:23 +02:00
type Action int
2019-09-05 06:09:56 +02:00
2019-05-13 01:27:26 +02:00
const (
maxSelectors = 30
)
2019-09-05 06:09:56 +02:00
const (
2019-09-05 06:09:56 +02:00
QTQuery QType = iota + 1
2019-11-25 08:22:33 +01:00
QTMutation
2019-10-14 08:51:36 +02:00
QTInsert
QTUpdate
QTDelete
QTUpsert
2019-05-13 01:27:26 +02:00
)
2019-03-24 14:57:29 +01:00
type QCode struct {
2019-10-14 08:51:36 +02:00
Type QType
ActionVar string
Selects []Select
2019-11-19 06:47:55 +01:00
Roots []int32
rootsA [5]int32
2019-03-24 14:57:29 +01:00
}
type Select struct {
2019-06-08 02:53:08 +02:00
ID int32
ParentID int32
2019-04-07 07:12:11 +02:00
Args map[string]*Node
Name string
2019-03-24 14:57:29 +01:00
FieldName string
2019-05-13 01:27:26 +02:00
Cols []Column
2019-03-24 14:57:29 +01:00
Where *Exp
OrderBy []*OrderBy
DistinctOn []string
Paging Paging
2019-06-08 02:53:08 +02:00
Children []int32
2019-10-14 08:51:36 +02:00
Functions bool
Allowed map[string]struct{}
PresetMap map[string]string
PresetList []string
2019-10-14 08:51:36 +02:00
}
type Column struct {
Table string
Name string
FieldName string
2019-03-24 14:57:29 +01:00
}
type Exp struct {
Op ExpOp
Col string
NestedCols []string
Type ValType
Val string
ListType ValType
ListVal []string
Children []*Exp
childrenA [5]*Exp
doFree bool
}
var zeroExp = Exp{doFree: true}
func (ex *Exp) Reset() {
*ex = zeroExp
2019-03-24 14:57:29 +01:00
}
type OrderBy struct {
Col string
Order Order
}
type Paging struct {
2019-10-14 08:51:36 +02:00
Limit string
Offset string
NoLimit bool
2019-03-24 14:57:29 +01:00
}
type ExpOp int
const (
2019-04-09 03:24:29 +02:00
OpNop ExpOp = iota
OpAnd
2019-03-24 14:57:29 +01:00
OpOr
OpNot
OpEquals
OpNotEquals
OpGreaterOrEquals
OpLesserOrEquals
OpGreaterThan
OpLesserThan
OpIn
OpNotIn
OpLike
OpNotLike
OpILike
OpNotILike
OpSimilar
OpNotSimilar
OpContains
OpContainedIn
OpHasKey
OpHasKeyAny
OpHasKeyAll
OpIsNull
2019-04-04 06:53:24 +02:00
OpEqID
OpTsQuery
OpFalse
2019-03-24 14:57:29 +01:00
)
type ValType int
const (
ValStr ValType = iota + 1
ValInt
ValFloat
ValBool
ValList
ValVar
ValNone
2019-03-24 14:57:29 +01:00
)
type AggregrateOp int
const (
AgCount AggregrateOp = iota + 1
AgSum
AgAvg
AgMax
AgMin
)
type Order int
const (
OrderAsc Order = iota + 1
OrderDesc
OrderAscNullsFirst
OrderAscNullsLast
OrderDescNullsFirst
OrderDescNullsLast
)
2019-04-08 08:47:59 +02:00
type Compiler struct {
2019-10-14 08:51:36 +02:00
tr map[string]map[string]*trval
2019-04-08 08:47:59 +02:00
bl map[string]struct{}
ka bool
2019-04-08 08:47:59 +02:00
}
var expPool = sync.Pool{
2019-10-03 09:08:01 +02:00
New: func() interface{} { return &Exp{doFree: true} },
}
func NewCompiler(c Config) (*Compiler, error) {
co := &Compiler{ka: c.KeepArgs}
2019-10-14 08:51:36 +02:00
co.tr = make(map[string]map[string]*trval)
co.bl = make(map[string]struct{}, len(c.Blocklist))
2019-04-08 08:47:59 +02:00
2019-09-08 07:54:38 +02:00
for i := range c.Blocklist {
2019-10-14 08:51:36 +02:00
co.bl[strings.ToLower(c.Blocklist[i])] = struct{}{}
}
2019-10-14 08:51:36 +02:00
seedExp := [100]Exp{}
2019-10-14 08:51:36 +02:00
for i := range seedExp {
seedExp[i].doFree = true
expPool.Put(&seedExp[i])
}
2019-10-14 08:51:36 +02:00
return co, nil
}
2019-10-14 08:51:36 +02:00
func (com *Compiler) AddRole(role, table string, trc TRConfig) error {
var err error
trv := &trval{}
2019-03-24 14:57:29 +01:00
2019-10-14 08:51:36 +02:00
// query config
2019-10-25 07:39:59 +02:00
trv.query.fil, err = compileFilter(trc.Query.Filters)
if err != nil {
2019-10-14 08:51:36 +02:00
return err
}
2019-10-14 08:51:36 +02:00
if trc.Query.Limit > 0 {
trv.query.limit = strconv.Itoa(trc.Query.Limit)
}
trv.query.cols = listToMap(trc.Query.Columns)
2019-10-14 08:51:36 +02:00
trv.query.disable.funcs = trc.Query.DisableFunctions
2019-03-24 14:57:29 +01:00
2019-10-14 08:51:36 +02:00
// insert config
2019-10-25 07:39:59 +02:00
if trv.insert.fil, err = compileFilter(trc.Insert.Filters); err != nil {
2019-10-14 08:51:36 +02:00
return err
}
trv.insert.cols = listToMap(trc.Insert.Columns)
trv.insert.psmap = parsePresets(trc.Insert.Presets)
trv.insert.pslist = mapToList(trv.insert.psmap)
2019-10-14 08:51:36 +02:00
// update config
2019-10-25 07:39:59 +02:00
if trv.update.fil, err = compileFilter(trc.Update.Filters); err != nil {
2019-10-14 08:51:36 +02:00
return err
}
trv.update.cols = listToMap(trc.Update.Columns)
trv.update.psmap = parsePresets(trc.Update.Presets)
trv.update.pslist = mapToList(trv.update.psmap)
2019-10-14 08:51:36 +02:00
// delete config
2019-10-25 07:39:59 +02:00
if trv.delete.fil, err = compileFilter(trc.Delete.Filters); err != nil {
2019-10-14 08:51:36 +02:00
return err
}
trv.delete.cols = listToMap(trc.Delete.Columns)
2019-10-14 08:51:36 +02:00
singular := flect.Singularize(table)
plural := flect.Pluralize(table)
2019-10-14 08:51:36 +02:00
if _, ok := com.tr[role]; !ok {
com.tr[role] = make(map[string]*trval)
2019-04-08 08:47:59 +02:00
}
2019-03-24 14:57:29 +01:00
2019-10-14 08:51:36 +02:00
com.tr[role][singular] = trv
com.tr[role][plural] = trv
return nil
2019-03-24 14:57:29 +01:00
}
2019-10-14 08:51:36 +02:00
func (com *Compiler) Compile(query []byte, role string) (*QCode, error) {
2019-03-24 14:57:29 +01:00
var err error
2019-10-14 08:51:36 +02:00
qc := QCode{Type: QTQuery}
2019-11-19 06:47:55 +01:00
qc.Roots = qc.rootsA[:0]
2019-10-14 08:51:36 +02:00
2019-06-15 04:17:21 +02:00
op, err := Parse(query)
2019-03-24 14:57:29 +01:00
if err != nil {
return nil, err
}
2019-10-14 08:51:36 +02:00
if err = com.compileQuery(&qc, op, role); err != nil {
2019-03-24 14:57:29 +01:00
return nil, err
}
2019-06-15 04:17:21 +02:00
opPool.Put(op)
2019-09-05 06:09:56 +02:00
return &qc, nil
2019-06-15 04:17:21 +02:00
}
2019-10-14 08:51:36 +02:00
func (com *Compiler) compileQuery(qc *QCode, op *Operation, role string) error {
2019-06-08 02:53:08 +02:00
id := int32(0)
2019-11-19 06:47:55 +01:00
parentID := int32(-1)
2019-03-24 14:57:29 +01:00
2019-10-14 08:51:36 +02:00
if len(op.Fields) == 0 {
return errors.New("invalid graphql no query found")
}
if op.Type == opMutate {
if err := com.setMutationType(qc, op.Fields[0].Args); err != nil {
return err
}
}
2019-05-13 01:27:26 +02:00
selects := make([]Select, 0, 5)
st := NewStack()
2019-10-14 08:51:36 +02:00
action := qc.Type
2019-03-24 14:57:29 +01:00
2019-05-13 01:27:26 +02:00
if len(op.Fields) == 0 {
2019-10-14 08:51:36 +02:00
return errors.New("empty query")
2019-03-24 14:57:29 +01:00
}
2019-11-19 06:47:55 +01:00
for i := range op.Fields {
if op.Fields[i].ParentID == -1 {
st.Push(op.Fields[i].ID)
}
}
2019-03-24 14:57:29 +01:00
for {
if st.Len() == 0 {
break
}
2019-05-13 01:27:26 +02:00
if id >= maxSelectors {
2019-10-14 08:51:36 +02:00
return fmt.Errorf("selector limit reached (%d)", maxSelectors)
2019-05-13 01:27:26 +02:00
}
fid := st.Pop()
2019-05-13 01:27:26 +02:00
field := &op.Fields[fid]
2019-03-24 14:57:29 +01:00
2019-06-15 04:17:21 +02:00
if _, ok := com.bl[field.Name]; ok {
2019-03-24 14:57:29 +01:00
continue
}
2019-10-15 08:30:19 +02:00
trv := com.getRole(role, field.Name)
2019-10-14 08:51:36 +02:00
selects = append(selects, Select{
ID: id,
ParentID: parentID,
Name: field.Name,
Children: make([]int32, 0, 5),
Allowed: trv.allowedColumns(action),
Functions: true,
})
s := &selects[(len(selects) - 1)]
2019-05-13 01:27:26 +02:00
switch action {
case QTQuery:
2019-10-14 08:51:36 +02:00
s.Functions = !trv.query.disable.funcs
s.Paging.Limit = trv.query.limit
2019-10-14 08:51:36 +02:00
case QTInsert:
s.PresetMap = trv.insert.psmap
s.PresetList = trv.insert.pslist
case QTUpdate:
s.PresetMap = trv.update.psmap
s.PresetList = trv.update.pslist
2019-10-14 08:51:36 +02:00
}
2019-03-24 14:57:29 +01:00
if len(field.Alias) != 0 {
s.FieldName = field.Alias
} else {
s.FieldName = s.Name
2019-03-24 14:57:29 +01:00
}
2019-10-14 08:51:36 +02:00
err := com.compileArgs(qc, s, field.Args)
2019-03-24 14:57:29 +01:00
if err != nil {
2019-10-14 08:51:36 +02:00
return err
2019-03-24 14:57:29 +01:00
}
2019-11-19 06:47:55 +01:00
// Order is important addFilters must come after compileArgs
com.addFilters(qc, s, role)
2019-11-19 06:47:55 +01:00
if s.ParentID == -1 {
qc.Roots = append(qc.Roots, s.ID)
} else {
p := &selects[s.ParentID]
p.Children = append(p.Children, s.ID)
}
2019-05-13 01:27:26 +02:00
s.Cols = make([]Column, 0, len(field.Children))
2019-10-14 08:51:36 +02:00
action = QTQuery
2019-05-13 01:27:26 +02:00
for _, cid := range field.Children {
f := op.Fields[cid]
2019-03-24 14:57:29 +01:00
2019-06-15 04:17:21 +02:00
if _, ok := com.bl[f.Name]; ok {
2019-03-24 14:57:29 +01:00
continue
}
2019-05-13 01:27:26 +02:00
if len(f.Children) != 0 {
parentID = s.ID
st.Push(f.ID)
continue
}
2019-06-15 04:17:21 +02:00
col := Column{Name: f.Name}
2019-05-13 01:27:26 +02:00
if len(f.Alias) != 0 {
col.FieldName = f.Alias
2019-03-24 14:57:29 +01:00
} else {
2019-05-13 01:27:26 +02:00
col.FieldName = f.Name
2019-03-24 14:57:29 +01:00
}
2019-05-13 01:27:26 +02:00
s.Cols = append(s.Cols, col)
2019-03-24 14:57:29 +01:00
}
2019-05-13 01:27:26 +02:00
id++
2019-03-24 14:57:29 +01:00
}
if id == 0 {
2019-10-14 08:51:36 +02:00
return errors.New("invalid query")
}
2019-11-19 06:47:55 +01:00
qc.Selects = selects[:id]
return nil
}
func (com *Compiler) addFilters(qc *QCode, root *Select, role string) {
var fil *Exp
if trv, ok := com.tr[role][root.Name]; ok {
2019-10-14 08:51:36 +02:00
fil = trv.filter(qc.Type)
}
2019-03-24 14:57:29 +01:00
2019-11-19 06:47:55 +01:00
if fil == nil {
return
}
switch fil.Op {
case OpNop:
case OpFalse:
root.Where = fil
default:
if root.Where != nil {
ow := root.Where
root.Where = expPool.Get().(*Exp)
root.Where.Reset()
root.Where.Op = OpAnd
root.Where.Children = root.Where.childrenA[:2]
root.Where.Children[0] = fil
root.Where.Children[1] = ow
} else {
root.Where = fil
}
2019-04-21 01:42:08 +02:00
}
2019-03-24 14:57:29 +01:00
}
2019-10-14 08:51:36 +02:00
func (com *Compiler) compileArgs(qc *QCode, sel *Select, args []Arg) error {
2019-03-24 14:57:29 +01:00
var err error
2019-04-07 07:12:11 +02:00
if com.ka {
sel.Args = make(map[string]*Node, len(args))
}
2019-03-24 14:57:29 +01:00
for i := range args {
arg := &args[i]
2019-06-15 04:17:21 +02:00
switch arg.Name {
2019-04-04 06:53:24 +02:00
case "id":
2019-10-14 08:51:36 +02:00
err = com.compileArgID(sel, arg)
case "search":
err = com.compileArgSearch(sel, arg)
2019-03-24 14:57:29 +01:00
case "where":
err = com.compileArgWhere(sel, arg)
2019-03-24 14:57:29 +01:00
case "orderby", "order_by", "order":
err = com.compileArgOrderBy(sel, arg)
2019-03-24 14:57:29 +01:00
case "distinct_on", "distinct":
err = com.compileArgDistinctOn(sel, arg)
2019-03-24 14:57:29 +01:00
case "limit":
err = com.compileArgLimit(sel, arg)
2019-03-24 14:57:29 +01:00
case "offset":
err = com.compileArgOffset(sel, arg)
2019-03-24 14:57:29 +01:00
}
2019-04-04 06:53:24 +02:00
if err != nil {
return err
}
if sel.Args != nil {
2019-06-15 04:17:21 +02:00
sel.Args[arg.Name] = arg.Val
} else {
nodePool.Put(arg.Val)
}
2019-03-24 14:57:29 +01:00
}
2019-04-04 06:53:24 +02:00
return nil
2019-03-24 14:57:29 +01:00
}
2019-10-14 08:51:36 +02:00
func (com *Compiler) setMutationType(qc *QCode, args []Arg) error {
setActionVar := func(arg *Arg) error {
if arg.Val.Type != nodeVar {
return fmt.Errorf("value for argument '%s' must be a variable", arg.Name)
}
qc.ActionVar = arg.Val.Val
return nil
}
for i := range args {
arg := &args[i]
switch arg.Name {
case "insert":
qc.Type = QTInsert
return setActionVar(arg)
case "update":
qc.Type = QTUpdate
return setActionVar(arg)
case "upsert":
qc.Type = QTUpsert
return setActionVar(arg)
case "delete":
qc.Type = QTDelete
if arg.Val.Type != nodeBool {
return fmt.Errorf("value for argument '%s' must be a boolean", arg.Name)
}
if arg.Val.Val == "false" {
qc.Type = QTQuery
}
return nil
}
}
return nil
}
2019-06-17 02:51:36 +02:00
func (com *Compiler) compileArgObj(st *util.Stack, arg *Arg) (*Exp, error) {
2019-03-24 14:57:29 +01:00
if arg.Val.Type != nodeObj {
2019-04-07 07:12:11 +02:00
return nil, fmt.Errorf("expecting an object")
2019-03-24 14:57:29 +01:00
}
2019-06-17 02:51:36 +02:00
return com.compileArgNode(st, arg.Val, true)
2019-03-24 14:57:29 +01:00
}
2019-06-17 02:51:36 +02:00
func (com *Compiler) compileArgNode(st *util.Stack, node *Node, usePool bool) (*Exp, error) {
2019-03-24 14:57:29 +01:00
var root *Exp
if node == nil || len(node.Children) == 0 {
return nil, errors.New("invalid argument value")
}
pushChild(st, nil, node)
2019-03-24 14:57:29 +01:00
for {
if st.Len() == 0 {
break
}
intf := st.Pop()
node, ok := intf.(*Node)
if !ok || node == nil {
2019-05-13 01:27:26 +02:00
return nil, fmt.Errorf("16: unexpected value %v (%t)", intf, intf)
2019-03-24 14:57:29 +01:00
}
2019-06-16 21:41:28 +02:00
// Objects inside a list
if len(node.Name) == 0 {
pushChildren(st, node.exp, node)
continue
} else {
if _, ok := com.bl[node.Name]; ok {
2019-04-07 07:12:11 +02:00
continue
}
2019-03-24 14:57:29 +01:00
}
ex, err := newExp(st, node, usePool)
if err != nil {
return nil, err
2019-03-24 14:57:29 +01:00
}
if ex == nil {
continue
2019-03-24 14:57:29 +01:00
}
if node.exp == nil {
2019-03-24 14:57:29 +01:00
root = ex
} else {
node.exp.Children = append(node.exp.Children, ex)
2019-03-24 14:57:29 +01:00
}
2019-03-24 14:57:29 +01:00
}
if com.ka {
return root, nil
}
pushChild(st, nil, node)
for {
if st.Len() == 0 {
break
}
intf := st.Pop()
node, _ := intf.(*Node)
for i := range node.Children {
st.Push(node.Children[i])
}
nodePool.Put(node)
}
2019-03-24 14:57:29 +01:00
return root, nil
}
2019-04-04 06:53:24 +02:00
func (com *Compiler) compileArgID(sel *Select, arg *Arg) error {
2019-10-14 08:51:36 +02:00
if sel.ID != 0 {
return nil
}
2019-04-04 06:53:24 +02:00
if sel.Where != nil && sel.Where.Op == OpEqID {
return nil
}
ex := expPool.Get().(*Exp)
ex.Reset()
ex.Op = OpEqID
ex.Val = arg.Val.Val
2019-04-04 06:53:24 +02:00
switch arg.Val.Type {
case nodeStr:
ex.Type = ValStr
case nodeInt:
ex.Type = ValInt
case nodeFloat:
ex.Type = ValFloat
2019-04-19 07:55:03 +02:00
case nodeVar:
ex.Type = ValVar
2019-04-04 06:53:24 +02:00
default:
2019-11-10 03:53:26 +01:00
return fmt.Errorf("expecting a string, int, float or variable")
2019-04-04 06:53:24 +02:00
}
sel.Where = ex
return nil
}
func (com *Compiler) compileArgSearch(sel *Select, arg *Arg) error {
ex := expPool.Get().(*Exp)
ex.Reset()
ex.Op = OpTsQuery
ex.Type = ValStr
ex.Val = arg.Val.Val
if sel.Where != nil {
2019-06-15 04:17:21 +02:00
ow := sel.Where
sel.Where = expPool.Get().(*Exp)
sel.Where.Reset()
sel.Where.Op = OpAnd
2019-06-15 04:17:21 +02:00
sel.Where.Children = sel.Where.childrenA[:2]
sel.Where.Children[0] = ex
sel.Where.Children[1] = ow
} else {
sel.Where = ex
}
return nil
}
2019-03-24 14:57:29 +01:00
func (com *Compiler) compileArgWhere(sel *Select, arg *Arg) error {
2019-06-17 02:51:36 +02:00
st := util.NewStack()
2019-03-24 14:57:29 +01:00
var err error
2019-06-17 02:51:36 +02:00
ex, err := com.compileArgObj(st, arg)
2019-03-24 14:57:29 +01:00
if err != nil {
return err
}
if sel.Where != nil {
2019-06-15 04:17:21 +02:00
ow := sel.Where
sel.Where = expPool.Get().(*Exp)
sel.Where.Reset()
sel.Where.Op = OpAnd
2019-06-15 04:17:21 +02:00
sel.Where.Children = sel.Where.childrenA[:2]
sel.Where.Children[0] = ex
sel.Where.Children[1] = ow
} else {
sel.Where = ex
}
2019-03-24 14:57:29 +01:00
return nil
}
func (com *Compiler) compileArgOrderBy(sel *Select, arg *Arg) error {
if arg.Val.Type != nodeObj {
return fmt.Errorf("expecting an object")
}
st := util.NewStack()
for i := range arg.Val.Children {
st.Push(arg.Val.Children[i])
}
for {
if st.Len() == 0 {
break
}
intf := st.Pop()
node, ok := intf.(*Node)
if !ok || node == nil {
2019-05-13 01:27:26 +02:00
return fmt.Errorf("17: unexpected value %v (%t)", intf, intf)
2019-03-24 14:57:29 +01:00
}
2019-06-15 04:17:21 +02:00
if _, ok := com.bl[node.Name]; ok {
if !com.ka {
nodePool.Put(node)
}
2019-03-24 14:57:29 +01:00
continue
}
if node.Type == nodeObj {
for i := range node.Children {
st.Push(node.Children[i])
}
if !com.ka {
nodePool.Put(node)
}
2019-03-24 14:57:29 +01:00
continue
}
ob := &OrderBy{}
2019-06-15 04:17:21 +02:00
switch node.Val {
2019-03-24 14:57:29 +01:00
case "asc":
ob.Order = OrderAsc
case "desc":
ob.Order = OrderDesc
case "asc_nulls_first":
ob.Order = OrderAscNullsFirst
case "desc_nulls_first":
ob.Order = OrderDescNullsFirst
case "asc_nulls_last":
ob.Order = OrderAscNullsLast
case "desc_nulls_last":
ob.Order = OrderDescNullsLast
default:
return fmt.Errorf("valid values include asc, desc, asc_nulls_first and desc_nulls_first")
}
setOrderByColName(ob, node)
sel.OrderBy = append(sel.OrderBy, ob)
if !com.ka {
nodePool.Put(node)
}
2019-03-24 14:57:29 +01:00
}
return nil
}
func (com *Compiler) compileArgDistinctOn(sel *Select, arg *Arg) error {
node := arg.Val
2019-06-15 04:17:21 +02:00
if _, ok := com.bl[node.Name]; ok {
2019-03-24 14:57:29 +01:00
return nil
}
if node.Type != nodeList && node.Type != nodeStr {
return fmt.Errorf("expecting a list of strings or just a string")
}
if node.Type == nodeStr {
sel.DistinctOn = append(sel.DistinctOn, node.Val)
}
for i := range node.Children {
sel.DistinctOn = append(sel.DistinctOn, node.Children[i].Val)
if !com.ka {
nodePool.Put(node.Children[i])
}
2019-03-24 14:57:29 +01:00
}
return nil
}
func (com *Compiler) compileArgLimit(sel *Select, arg *Arg) error {
node := arg.Val
if node.Type != nodeInt {
return fmt.Errorf("expecting an integer")
}
sel.Paging.Limit = node.Val
return nil
}
func (com *Compiler) compileArgOffset(sel *Select, arg *Arg) error {
node := arg.Val
if node.Type != nodeInt {
return fmt.Errorf("expecting an integer")
}
sel.Paging.Offset = node.Val
return nil
}
2019-10-15 08:30:19 +02:00
var zeroTrv = &trval{}
func (com *Compiler) getRole(role, field string) *trval {
if trv, ok := com.tr[role][field]; ok {
return trv
} else {
return zeroTrv
}
}
func newExp(st *util.Stack, node *Node, usePool bool) (*Exp, error) {
2019-06-15 04:17:21 +02:00
name := node.Name
if name[0] == '_' {
name = name[1:]
}
var ex *Exp
if usePool {
ex = expPool.Get().(*Exp)
ex.Reset()
} else {
2019-10-03 09:08:01 +02:00
ex = &Exp{doFree: false}
}
ex.Children = ex.childrenA[:0]
2019-06-15 04:17:21 +02:00
switch name {
case "and":
2019-06-16 21:41:28 +02:00
if len(node.Children) == 0 {
return nil, errors.New("missing expression after 'AND' operator")
}
ex.Op = OpAnd
pushChildren(st, ex, node)
case "or":
2019-06-16 21:41:28 +02:00
if len(node.Children) == 0 {
return nil, errors.New("missing expression after 'OR' operator")
}
ex.Op = OpOr
pushChildren(st, ex, node)
case "not":
2019-06-16 21:41:28 +02:00
if len(node.Children) == 0 {
return nil, errors.New("missing expression after 'NOT' operator")
}
ex.Op = OpNot
pushChild(st, ex, node)
case "eq", "equals":
ex.Op = OpEquals
ex.Val = node.Val
case "neq", "not_equals":
ex.Op = OpNotEquals
ex.Val = node.Val
case "gt", "greater_than":
ex.Op = OpGreaterThan
ex.Val = node.Val
case "lt", "lesser_than":
ex.Op = OpLesserThan
ex.Val = node.Val
case "gte", "greater_or_equals":
ex.Op = OpGreaterOrEquals
ex.Val = node.Val
case "lte", "lesser_or_equals":
ex.Op = OpLesserOrEquals
ex.Val = node.Val
case "in":
ex.Op = OpIn
setListVal(ex, node)
case "nin", "not_in":
ex.Op = OpNotIn
setListVal(ex, node)
case "like":
ex.Op = OpLike
ex.Val = node.Val
case "nlike", "not_like":
ex.Op = OpNotLike
ex.Val = node.Val
case "ilike":
ex.Op = OpILike
ex.Val = node.Val
case "nilike", "not_ilike":
ex.Op = OpILike
ex.Val = node.Val
case "similar":
ex.Op = OpSimilar
ex.Val = node.Val
case "nsimilar", "not_similar":
ex.Op = OpNotSimilar
ex.Val = node.Val
case "contains":
ex.Op = OpContains
ex.Val = node.Val
case "contained_in":
ex.Op = OpContainedIn
ex.Val = node.Val
case "has_key":
ex.Op = OpHasKey
ex.Val = node.Val
case "has_key_any":
ex.Op = OpHasKeyAny
ex.Val = node.Val
case "has_key_all":
ex.Op = OpHasKeyAll
ex.Val = node.Val
case "is_null":
ex.Op = OpIsNull
ex.Val = node.Val
default:
pushChildren(st, node.exp, node)
return nil, nil // skip node
}
if ex.Op != OpAnd && ex.Op != OpOr && ex.Op != OpNot {
switch node.Type {
case nodeStr:
ex.Type = ValStr
case nodeInt:
ex.Type = ValInt
case nodeBool:
ex.Type = ValBool
case nodeFloat:
ex.Type = ValFloat
case nodeList:
ex.Type = ValList
case nodeVar:
ex.Type = ValVar
default:
return nil, fmt.Errorf("[Where] valid values include string, int, float, boolean and list: %s", node.Type)
}
setWhereColName(ex, node)
}
return ex, nil
}
2019-03-24 14:57:29 +01:00
func setListVal(ex *Exp, node *Node) {
if len(node.Children) != 0 {
switch node.Children[0].Type {
case nodeStr:
ex.ListType = ValStr
case nodeInt:
ex.ListType = ValInt
case nodeBool:
ex.ListType = ValBool
case nodeFloat:
ex.ListType = ValFloat
}
}
for i := range node.Children {
ex.ListVal = append(ex.ListVal, node.Children[i].Val)
}
}
func setWhereColName(ex *Exp, node *Node) {
var list []string
2019-05-13 01:27:26 +02:00
2019-03-24 14:57:29 +01:00
for n := node.Parent; n != nil; n = n.Parent {
if n.Type != nodeObj {
continue
}
2019-05-13 01:27:26 +02:00
if len(n.Name) != 0 {
2019-06-15 04:17:21 +02:00
k := n.Name
2019-05-13 01:27:26 +02:00
if k == "and" || k == "or" || k == "not" ||
k == "_and" || k == "_or" || k == "_not" {
continue
}
2019-03-24 14:57:29 +01:00
list = append([]string{k}, list...)
}
}
if len(list) == 1 {
ex.Col = list[0]
} else if len(list) > 1 {
ex.NestedCols = list
2019-03-24 14:57:29 +01:00
}
}
func setOrderByColName(ob *OrderBy, node *Node) {
var list []string
2019-05-13 01:27:26 +02:00
2019-03-24 14:57:29 +01:00
for n := node; n != nil; n = n.Parent {
2019-05-13 01:27:26 +02:00
if len(n.Name) != 0 {
2019-06-15 04:17:21 +02:00
list = append([]string{n.Name}, list...)
2019-03-24 14:57:29 +01:00
}
}
if len(list) != 0 {
2019-05-13 01:27:26 +02:00
ob.Col = buildPath(list)
2019-03-24 14:57:29 +01:00
}
}
func pushChildren(st *util.Stack, exp *Exp, node *Node) {
2019-03-24 14:57:29 +01:00
for i := range node.Children {
node.Children[i].exp = exp
st.Push(node.Children[i])
2019-03-24 14:57:29 +01:00
}
}
2019-04-08 08:47:59 +02:00
func pushChild(st *util.Stack, exp *Exp, node *Node) {
node.Children[0].exp = exp
st.Push(node.Children[0])
2019-06-16 21:41:28 +02:00
}
2019-04-08 08:47:59 +02:00
func compileFilter(filter []string) (*Exp, error) {
var fl *Exp
com := &Compiler{}
2019-06-17 02:51:36 +02:00
st := util.NewStack()
2019-04-08 08:47:59 +02:00
2019-04-09 03:24:29 +02:00
if len(filter) == 0 {
2019-10-03 09:08:01 +02:00
return &Exp{Op: OpNop, doFree: false}, nil
2019-04-09 03:24:29 +02:00
}
2019-04-08 08:47:59 +02:00
for i := range filter {
if filter[i] == "false" {
return &Exp{Op: OpFalse, doFree: false}, nil
}
2019-04-08 08:47:59 +02:00
node, err := ParseArgValue(filter[i])
if err != nil {
return nil, err
}
2019-06-17 02:51:36 +02:00
f, err := com.compileArgNode(st, node, false)
2019-04-08 08:47:59 +02:00
if err != nil {
return nil, err
}
2019-10-03 09:08:01 +02:00
2019-04-08 08:47:59 +02:00
if fl == nil {
fl = f
} else {
2019-10-03 09:08:01 +02:00
fl = &Exp{Op: OpAnd, Children: []*Exp{fl, f}, doFree: false}
2019-04-08 08:47:59 +02:00
}
}
return fl, nil
}
2019-05-13 01:27:26 +02:00
func buildPath(a []string) string {
switch len(a) {
case 0:
return ""
case 1:
return a[0]
}
n := len(a) - 1
for i := 0; i < len(a); i++ {
n += len(a[i])
}
var b strings.Builder
b.Grow(n)
b.WriteString(a[0])
for _, s := range a[1:] {
b.WriteRune('.')
b.WriteString(s)
}
return b.String()
}
func (t ExpOp) String() string {
var v string
switch t {
case OpNop:
v = "op-nop"
case OpAnd:
v = "op-and"
case OpOr:
v = "op-or"
case OpNot:
v = "op-not"
case OpEquals:
v = "op-equals"
case OpNotEquals:
v = "op-not-equals"
case OpGreaterOrEquals:
v = "op-greater-or-equals"
case OpLesserOrEquals:
v = "op-lesser-or-equals"
case OpGreaterThan:
v = "op-greater-than"
case OpLesserThan:
v = "op-lesser-than"
case OpIn:
v = "op-in"
case OpNotIn:
v = "op-not-in"
case OpLike:
v = "op-like"
case OpNotLike:
v = "op-not-like"
case OpILike:
v = "op-i-like"
case OpNotILike:
v = "op-not-i-like"
case OpSimilar:
v = "op-similar"
case OpNotSimilar:
v = "op-not-similar"
case OpContains:
v = "op-contains"
case OpContainedIn:
v = "op-contained-in"
case OpHasKey:
v = "op-has-key"
case OpHasKeyAny:
v = "op-has-key-any"
case OpHasKeyAll:
v = "op-has-key-all"
case OpIsNull:
v = "op-is-null"
case OpEqID:
v = "op-eq-id"
case OpTsQuery:
v = "op-ts-query"
}
return fmt.Sprintf("<%s>", v)
}
func FreeExp(ex *Exp) {
2019-10-03 09:08:01 +02:00
// fmt.Println(">", ex.doFree)
if ex.doFree {
expPool.Put(ex)
}
}