833 lines
14 KiB
Go
833 lines
14 KiB
Go
package qcode
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"strings"
|
|
|
|
"github.com/dosco/super-graph/util"
|
|
"github.com/gobuffalo/flect"
|
|
)
|
|
|
|
type QCode struct {
|
|
Query *Query
|
|
}
|
|
|
|
type Query struct {
|
|
Select *Select
|
|
}
|
|
|
|
type Column struct {
|
|
Table string
|
|
Name string
|
|
FieldName string
|
|
}
|
|
|
|
type Select struct {
|
|
ID int16
|
|
Args map[string]*Node
|
|
AsList bool
|
|
Table string
|
|
Singular string
|
|
FieldName string
|
|
Cols []*Column
|
|
Where *Exp
|
|
OrderBy []*OrderBy
|
|
DistinctOn []string
|
|
Paging Paging
|
|
Joins []*Select
|
|
}
|
|
|
|
type Exp struct {
|
|
Op ExpOp
|
|
Col string
|
|
NestedCol bool
|
|
Type ValType
|
|
Val string
|
|
ListType ValType
|
|
ListVal []string
|
|
Children []*Exp
|
|
}
|
|
|
|
type OrderBy struct {
|
|
Col string
|
|
Order Order
|
|
}
|
|
|
|
type Paging struct {
|
|
Limit string
|
|
Offset string
|
|
}
|
|
|
|
type ExpOp int
|
|
|
|
const (
|
|
OpNop ExpOp = iota
|
|
OpAnd
|
|
OpOr
|
|
OpNot
|
|
OpEquals
|
|
OpNotEquals
|
|
OpGreaterOrEquals
|
|
OpLesserOrEquals
|
|
OpGreaterThan
|
|
OpLesserThan
|
|
OpIn
|
|
OpNotIn
|
|
OpLike
|
|
OpNotLike
|
|
OpILike
|
|
OpNotILike
|
|
OpSimilar
|
|
OpNotSimilar
|
|
OpContains
|
|
OpContainedIn
|
|
OpHasKey
|
|
OpHasKeyAny
|
|
OpHasKeyAll
|
|
OpIsNull
|
|
OpEqID
|
|
OpTsQuery
|
|
)
|
|
|
|
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)
|
|
}
|
|
|
|
type ValType int
|
|
|
|
const (
|
|
ValStr ValType = iota + 1
|
|
ValInt
|
|
ValFloat
|
|
ValBool
|
|
ValList
|
|
ValVar
|
|
ValNone
|
|
)
|
|
|
|
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
|
|
)
|
|
|
|
type Config struct {
|
|
Filter []string
|
|
FilterMap map[string][]string
|
|
Blacklist []string
|
|
}
|
|
|
|
type Compiler struct {
|
|
fl *Exp
|
|
fm map[string]*Exp
|
|
bl map[string]struct{}
|
|
}
|
|
|
|
func NewCompiler(conf Config) (*Compiler, error) {
|
|
bl := make(map[string]struct{}, len(conf.Blacklist))
|
|
|
|
for i := range conf.Blacklist {
|
|
bl[strings.ToLower(conf.Blacklist[i])] = struct{}{}
|
|
}
|
|
|
|
fl, err := compileFilter(conf.Filter)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
fm := make(map[string]*Exp, len(conf.FilterMap))
|
|
|
|
for k, v := range conf.FilterMap {
|
|
fil, err := compileFilter(v)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
fm[strings.ToLower(k)] = fil
|
|
}
|
|
|
|
return &Compiler{fl, fm, bl}, nil
|
|
}
|
|
|
|
func (com *Compiler) CompileQuery(query string) (*QCode, error) {
|
|
var qc QCode
|
|
var err error
|
|
|
|
op, err := ParseQuery(query)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
switch op.Type {
|
|
case opQuery:
|
|
qc.Query, err = com.compileQuery(op)
|
|
case opMutate:
|
|
case opSub:
|
|
default:
|
|
err = fmt.Errorf("Unknown operation type %d", op.Type)
|
|
}
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &qc, nil
|
|
}
|
|
|
|
func (com *Compiler) compileQuery(op *Operation) (*Query, error) {
|
|
var selRoot *Select
|
|
|
|
st := util.NewStack()
|
|
id := int16(0)
|
|
fs := make([]*Select, op.FieldLen)
|
|
|
|
for i := range op.Fields {
|
|
st.Push(op.Fields[i])
|
|
}
|
|
|
|
for {
|
|
if st.Len() == 0 {
|
|
break
|
|
}
|
|
|
|
intf := st.Pop()
|
|
field, ok := intf.(*Field)
|
|
|
|
if !ok || field == nil {
|
|
return nil, fmt.Errorf("unexpected value poped out %v", intf)
|
|
}
|
|
|
|
fn := strings.ToLower(field.Name)
|
|
if _, ok := com.bl[fn]; ok {
|
|
continue
|
|
}
|
|
tn := flect.Pluralize(fn)
|
|
|
|
s := &Select{
|
|
ID: id,
|
|
Table: tn,
|
|
}
|
|
|
|
if fn == tn {
|
|
s.Singular = flect.Singularize(fn)
|
|
} else {
|
|
s.Singular = fn
|
|
}
|
|
|
|
if fn == s.Table {
|
|
s.AsList = true
|
|
} else {
|
|
s.Paging.Limit = "1"
|
|
}
|
|
|
|
if len(field.Alias) != 0 {
|
|
s.FieldName = field.Alias
|
|
} else if s.AsList {
|
|
s.FieldName = s.Table
|
|
} else {
|
|
s.FieldName = s.Singular
|
|
}
|
|
|
|
id++
|
|
fs[field.ID] = s
|
|
|
|
err := com.compileArgs(s, field.Args)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
for i := range field.Children {
|
|
f := field.Children[i]
|
|
fn := strings.ToLower(f.Name)
|
|
|
|
if _, ok := com.bl[fn]; ok {
|
|
continue
|
|
}
|
|
|
|
if f.Children == nil {
|
|
col := &Column{Name: fn}
|
|
if len(f.Alias) != 0 {
|
|
col.FieldName = f.Alias
|
|
} else {
|
|
col.FieldName = f.Name
|
|
}
|
|
|
|
s.Cols = append(s.Cols, col)
|
|
} else {
|
|
st.Push(f)
|
|
}
|
|
}
|
|
|
|
if field.Parent == nil {
|
|
selRoot = s
|
|
} else {
|
|
sp := fs[field.Parent.ID]
|
|
sp.Joins = append(sp.Joins, s)
|
|
}
|
|
}
|
|
|
|
var ok bool
|
|
var fil *Exp
|
|
|
|
if selRoot != nil {
|
|
fil, ok = com.fm[selRoot.Table]
|
|
}
|
|
|
|
if !ok || fil == nil {
|
|
fil = com.fl
|
|
}
|
|
|
|
if fil != nil && fil.Op != OpNop {
|
|
if selRoot.Where != nil {
|
|
selRoot.Where = &Exp{Op: OpAnd, Children: []*Exp{fil, selRoot.Where}}
|
|
} else {
|
|
selRoot.Where = fil
|
|
}
|
|
}
|
|
|
|
if selRoot == nil {
|
|
return nil, errors.New("invalid query")
|
|
}
|
|
|
|
return &Query{selRoot}, nil
|
|
}
|
|
|
|
func (com *Compiler) compileArgs(sel *Select, args []*Arg) error {
|
|
var err error
|
|
|
|
sel.Args = make(map[string]*Node, len(args))
|
|
|
|
for i := range args {
|
|
if args[i] == nil {
|
|
return fmt.Errorf("[Args] unexpected nil argument found")
|
|
}
|
|
an := strings.ToLower(args[i].Name)
|
|
if _, ok := sel.Args[an]; ok {
|
|
continue
|
|
}
|
|
|
|
switch an {
|
|
case "id":
|
|
if sel.ID == int16(0) {
|
|
err = com.compileArgID(sel, args[i])
|
|
}
|
|
case "search":
|
|
err = com.compileArgSearch(sel, args[i])
|
|
case "where":
|
|
err = com.compileArgWhere(sel, args[i])
|
|
case "orderby", "order_by", "order":
|
|
err = com.compileArgOrderBy(sel, args[i])
|
|
case "distinct_on", "distinct":
|
|
err = com.compileArgDistinctOn(sel, args[i])
|
|
case "limit":
|
|
err = com.compileArgLimit(sel, args[i])
|
|
case "offset":
|
|
err = com.compileArgOffset(sel, args[i])
|
|
}
|
|
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
sel.Args[an] = args[i].Val
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
type expT struct {
|
|
parent *Exp
|
|
node *Node
|
|
}
|
|
|
|
func (com *Compiler) compileArgObj(arg *Arg) (*Exp, error) {
|
|
if arg.Val.Type != nodeObj {
|
|
return nil, fmt.Errorf("expecting an object")
|
|
}
|
|
|
|
return com.compileArgNode(arg.Val)
|
|
}
|
|
|
|
func (com *Compiler) compileArgNode(val *Node) (*Exp, error) {
|
|
st := util.NewStack()
|
|
var root *Exp
|
|
|
|
st.Push(&expT{nil, val.Children[0]})
|
|
|
|
for {
|
|
if st.Len() == 0 {
|
|
break
|
|
}
|
|
|
|
intf := st.Pop()
|
|
eT, ok := intf.(*expT)
|
|
if !ok || eT == nil {
|
|
return nil, fmt.Errorf("unexpected value poped out %v", intf)
|
|
}
|
|
|
|
if len(eT.node.Name) != 0 {
|
|
if _, ok := com.bl[strings.ToLower(eT.node.Name)]; ok {
|
|
continue
|
|
}
|
|
}
|
|
|
|
ex, err := newExp(st, eT)
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if ex == nil {
|
|
continue
|
|
}
|
|
|
|
if eT.parent == nil {
|
|
root = ex
|
|
} else {
|
|
eT.parent.Children = append(eT.parent.Children, ex)
|
|
}
|
|
}
|
|
|
|
return root, nil
|
|
}
|
|
|
|
func (com *Compiler) compileArgID(sel *Select, arg *Arg) error {
|
|
if sel.Where != nil && sel.Where.Op == OpEqID {
|
|
return nil
|
|
}
|
|
|
|
ex := &Exp{Op: OpEqID, Val: arg.Val.Val}
|
|
|
|
switch arg.Val.Type {
|
|
case nodeStr:
|
|
ex.Type = ValStr
|
|
case nodeInt:
|
|
ex.Type = ValInt
|
|
case nodeFloat:
|
|
ex.Type = ValFloat
|
|
case nodeVar:
|
|
ex.Type = ValVar
|
|
default:
|
|
fmt.Errorf("expecting a string, int, float or variable")
|
|
}
|
|
|
|
sel.Where = ex
|
|
return nil
|
|
}
|
|
|
|
func (com *Compiler) compileArgSearch(sel *Select, arg *Arg) error {
|
|
ex := &Exp{
|
|
Op: OpTsQuery,
|
|
Type: ValStr,
|
|
Val: arg.Val.Val,
|
|
}
|
|
|
|
if sel.Where != nil {
|
|
sel.Where = &Exp{Op: OpAnd, Children: []*Exp{ex, sel.Where}}
|
|
} else {
|
|
sel.Where = ex
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (com *Compiler) compileArgWhere(sel *Select, arg *Arg) error {
|
|
var err error
|
|
|
|
ex, err := com.compileArgObj(arg)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if sel.Where != nil {
|
|
sel.Where = &Exp{Op: OpAnd, Children: []*Exp{ex, sel.Where}}
|
|
} else {
|
|
sel.Where = ex
|
|
}
|
|
|
|
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 {
|
|
return fmt.Errorf("OrderBy: unexpected value poped out %v", intf)
|
|
}
|
|
|
|
if _, ok := com.bl[strings.ToLower(node.Name)]; ok {
|
|
continue
|
|
}
|
|
|
|
if node.Type == nodeObj {
|
|
for i := range node.Children {
|
|
st.Push(node.Children[i])
|
|
}
|
|
continue
|
|
}
|
|
|
|
ob := &OrderBy{}
|
|
|
|
val := strings.ToLower(node.Val)
|
|
switch val {
|
|
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)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (com *Compiler) compileArgDistinctOn(sel *Select, arg *Arg) error {
|
|
node := arg.Val
|
|
|
|
if _, ok := com.bl[strings.ToLower(node.Name)]; ok {
|
|
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)
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
func compileMutate() (*Query, error) {
|
|
return nil, nil
|
|
}
|
|
|
|
func compileSub() (*Query, error) {
|
|
return nil, nil
|
|
}
|
|
|
|
func newExp(st *util.Stack, eT *expT) (*Exp, error) {
|
|
ex := &Exp{}
|
|
node := eT.node
|
|
|
|
if len(node.Name) == 0 {
|
|
pushChildren(st, eT.parent, node)
|
|
return nil, nil
|
|
}
|
|
|
|
name := strings.ToLower(node.Name)
|
|
if name[0] == '_' {
|
|
name = name[1:]
|
|
}
|
|
|
|
switch name {
|
|
case "and":
|
|
ex.Op = OpAnd
|
|
pushChildren(st, ex, node)
|
|
case "or":
|
|
ex.Op = OpOr
|
|
pushChildren(st, ex, node)
|
|
case "not":
|
|
ex.Op = OpNot
|
|
st.Push(&expT{ex, node.Children[0]})
|
|
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, eT.parent, 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
|
|
}
|
|
|
|
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
|
|
for n := node.Parent; n != nil; n = n.Parent {
|
|
if n.Type != nodeObj {
|
|
continue
|
|
}
|
|
k := strings.ToLower(n.Name)
|
|
if k == "and" || k == "or" || k == "not" ||
|
|
k == "_and" || k == "_or" || k == "_not" {
|
|
continue
|
|
}
|
|
if len(k) != 0 {
|
|
list = append([]string{k}, list...)
|
|
}
|
|
}
|
|
if len(list) == 1 {
|
|
ex.Col = list[0]
|
|
|
|
} else if len(list) > 2 {
|
|
ex.Col = strings.Join(list, ".")
|
|
ex.NestedCol = true
|
|
}
|
|
}
|
|
|
|
func setOrderByColName(ob *OrderBy, node *Node) {
|
|
var list []string
|
|
for n := node; n != nil; n = n.Parent {
|
|
k := strings.ToLower(n.Name)
|
|
if len(k) != 0 {
|
|
list = append([]string{k}, list...)
|
|
}
|
|
}
|
|
if len(list) != 0 {
|
|
ob.Col = strings.Join(list, ".")
|
|
}
|
|
}
|
|
|
|
func pushChildren(st *util.Stack, ex *Exp, node *Node) {
|
|
for i := range node.Children {
|
|
st.Push(&expT{ex, node.Children[i]})
|
|
}
|
|
}
|
|
|
|
func compileFilter(filter []string) (*Exp, error) {
|
|
var fl *Exp
|
|
com := &Compiler{}
|
|
|
|
if len(filter) == 0 {
|
|
return &Exp{Op: OpNop}, nil
|
|
}
|
|
|
|
for i := range filter {
|
|
node, err := ParseArgValue(filter[i])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
f, err := com.compileArgNode(node)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if fl == nil {
|
|
fl = f
|
|
} else {
|
|
fl = &Exp{Op: OpAnd, Children: []*Exp{fl, f}}
|
|
}
|
|
}
|
|
return fl, nil
|
|
}
|