This library provide generic boolean expression parser to go structures.
$ go get -u github.com/mgudov/logic-expression-parser (optional) Run unit tests
$ make test (optional) Run benchmarks
$ make bench package main import ( "github.com/davecgh/go-spew/spew" lep "github.com/mgudov/logic-expression-parser" ) func main() { expression := `a=false && b>=c && (d<1000 || e in [1,2,3])` result, err := lep.ParseExpression(expression) if err != nil { panic(err) } dump := spew.NewDefaultConfig() dump.DisablePointerAddresses = true dump.DisableMethods = true dump.Dump(result) }This library would parse the expression and return the following struct:
(*lep.AndX)({ Conjuncts: ([]lep.Expression) (len=3 cap=4) { (*lep.EqualsX)({ Param: (*lep.ParamX)({ Name: (string) (len=1) "a" }), Value: (*lep.BooleanX)({ Val: (bool) false }) }), (*lep.GreaterThanEqualX)({ Param: (*lep.ParamX)({ Name: (string) (len=1) "b" }), Value: (*lep.ParamX)({ Name: (string) (len=1) "c" }) }), (*lep.OrX)({ Disjunctions: ([]lep.Expression) (len=2 cap=2) { (*lep.LessThanX)({ Param: (*lep.ParamX)({ Name: (string) (len=1) "d" }), Value: (*lep.IntegerX)({ Val: (int64) 1000 }) }), (*lep.InSliceX)({ Param: (*lep.ParamX)({ Name: (string) (len=1) "e" }), Slice: (*lep.SliceX)({ Values: ([]lep.Value) (len=3 cap=4) { (*lep.IntegerX)({ Val: (int64) 1 }), (*lep.IntegerX)({ Val: (int64) 2 }), (*lep.IntegerX)({ Val: (int64) 3 }) } }) }) } }) } }) Use can also create expression string from code:
package main import ( "fmt" lep "github.com/mgudov/logic-expression-parser" ) func main() { expression := lep.And( lep.Equals(lep.Param("a"), lep.Boolean(false)), lep.GreaterThanEqual(lep.Param("b"), lep.Param("c")), lep.Or( lep.LessThan(lep.Param("d"), lep.Integer(1000)), lep.InSlice( lep.Param("e"), lep.Slice(lep.Integer(1), lep.Integer(2), lep.Integer(3)), ), ), ) fmt.Println(expression.String()) }a=false && b>=c && (d<1000 || e in [1,2,3]) Create SQL query from expression string
package main import ( "fmt" "github.com/davecgh/go-spew/spew" sb "github.com/huandu/go-sqlbuilder" lep "github.com/mgudov/logic-expression-parser" ) func traverse(sql *sb.SelectBuilder, expr lep.Expression) (string, error) { switch e := expr.(type) { default: return "", fmt.Errorf("not implemented: %T", e) case *lep.OrX: var args []string for _, disjunction := range e.Disjunctions { arg, err := traverse(sql, disjunction) if err != nil { return "", err } args = append(args, arg) } return sql.Or(args...), nil case *lep.AndX: var args []string for _, conjunct := range e.Conjuncts { arg, err := traverse(sql, conjunct) if err != nil { return "", err } args = append(args, arg) } return sql.And(args...), nil case *lep.EqualsX: value := e.Value.Value() if value == nil { return sql.IsNotNull(e.Param.String()), nil } return sql.Equal(e.Param.String(), value), nil case *lep.NotEqualsX: value := e.Value.Value() if value == nil { return sql.IsNotNull(e.Param.String()), nil } return sql.NotEqual(e.Param.String(), value), nil case *lep.GreaterThanX: return sql.GreaterThan(e.Param.String(), e.Value.Value()), nil case *lep.InSliceX: var items []interface{} for _, value := range e.Slice.Values { items = append(items, value.Value()) } return sql.In(e.Param.String(), items...), nil // TODO: other cases } } func main() { query := `active=true && email!=null && (last_login>dt:"2010-01-01" || role in ["client","customer"])` expr, err := lep.ParseExpression(query) if err != nil { panic(err) } sql := sb.Select("*").From("users") where, err := traverse(sql, expr) if err != nil { panic(err) } sql.Where(where) spew.Dump(sql.Build()) }(string) (len=99) "SELECT * FROM users WHERE (active = ? AND email IS NOT NULL AND (last_login > ? OR role IN (?, ?)))" ([]interface {}) (len=4 cap=4) { (bool) true, (time.Time) 2010-01-01 00:00:00 +0000 UTC, (string) (len=6) "client", (string) (len=8) "customer" } - Comparators:
=!=>>=<<=(left - param, right - param or value) - Logical operations:
||&&(left, right - any statements) - Numeric constants: integer 64-bit (
12345678), float 64-bit with floating point (12345.678) - String constants (double quotes:
"foo bar","foo "bar"") - String operations:
starts_with,ends_with(left - param, right - param or string) - Regexp operations:
=~(match regexpa =~ /[a-z]+/),!~(not matchb !~ /[0-9]+/) - Date constants (double quotes after
dt:):dt:"2020-03-04 10:20:30"(for parsing datetime used dateparse) - Arrays (any values separated by
,within square bracket:[1,2,"foo",dt:"1999-09-09"]) - Array operations:
innot_in(a in [1,2,3]) - Boolean constants:
truefalse - Null constant:
null
Here are the results output from a benchmark run on a Macbook Pro 2018:
go test -benchmem -bench=. goos: darwin goarch: amd64 pkg: github.com/mgudov/logic-expression-parser cpu: Intel(R) Core(TM) i9-9880H CPU @ 2.30GHz BenchmarkSmallQuery-16 26547 45293 ns/op 19353 B/op 332 allocs/op BenchmarkMediumQuery-16 10000 106334 ns/op 42931 B/op 807 allocs/op BenchmarkLargeQuery-16 3268 331438 ns/op 114500 B/op 2385 allocs/op BenchmarkSmallQueryWithMemo-16 14696 79791 ns/op 82590 B/op 276 allocs/op BenchmarkMediumQueryWithMemo-16 4924 246504 ns/op 257072 B/op 746 allocs/op BenchmarkLargeQueryWithMemo-16 2071 590092 ns/op 594584 B/op 1627 allocs/op PASS ok github.com/mgudov/logic-expression-parser 8.744s For parsing string the pigeon parser generator is used (Licensed under BSD 3-Clause).