rules_engine

rules engine to filter and reshape json

Example

Use rule engine by sql,only support 'select ... from ... where ...'

    eng := NewJsonEngine(true).
        RegisterRuleFunction("clientid", 
            func(i rule.Rule) func([]interface{}) interface{} {
                    return func([]interface{}) interface{} {
                        return i.Name()
                }
            })
    
    //sql keywords'case insensitive
    _, err := eng.ParseSql(
                `select 
                    "3" as a.a,
                    'hello' as a.b,
                    Sum(b.c) as a.c,
                    Substr(c,2,4) as a.d,
                    string(year(currenttimestamp())) as a.e,
                    * as a.f,
                    ceil(1.5) as c.a,
                    max(b.c) as c.b,
                    min(b.c) as c.c,
                    array(1,a,3) as c.d,
                    b.f,
                    b.c,
                    clientid() as c.d,
                    b.c[2] + b.c[3] as b.b 
                from "aaa/bbb"
                where a < 2 and b.c[4] = 5 and e.f = 2`)
    if err != nil {
        fmt.Println(err)
    }

    text := `{"a":1,"b":{"c":[1,2,3,4,5]},"c":"123456789","e":{"f":2}}`
    jsonText, err := eng.ConvertJson("aaa/bbb",text)
     if err != nil {
        fmt.Println(err)
    }
    fmt.Println(string(jsonText))
    /*output
    {
        "a": {
            "a": "3",
            "b": "hello",
            "c": 15,
            "d": "3456",
            "e": "2019",
            "f": {
                "a": 1,
                "b": {
                    "c": [
                        1,
                        2,
                        3,
                        4,
                        5
                    ]
                },
                "c": "123456789",
                "e": {
                    "f": 2
                }
            }
        },
        "b": {
            "b": 7,
            "c": [
                1,
                2,
                3,
                4,
                5
            ]
        },
        "c": {
            "a": 2,
            "b": 5,
            "c": 1,
            "d": [
                1,
                1,
                3
            ],
            "e": "aaa/bbb"
        }
    }*/
    
    text = `{"a":5,"b":{"c":[6,5,4,3,2,1]},"c":"987654321"}`
    jsonText, err = eng.ConvertJson("aaa/bbb",text)
     if err != nil {
        fmt.Println(err)
    }
    fmt.Println(string(jsonText)) // null

Use rule

    rule := rule.NewJsonRule(true)
    
    //query
    fieldFilter := filter.NewFieldFilter(nil)
    fieldFilter.Parse("a < 2 && b.c[4] == 5 && e.f == 2")

    rule.AddHandler(fieldFilter)

    m := mapper.NewMapper(nil)

    //select fields
    m.AddField("3", "a.a")
    m.AddField("'hello'", "a.b")
    m.AddField("Sum(b.c)", "a.c")
    m.AddField("Substr(c,2)", "a.d")
    m.AddCurrentTimestampField("a.e", nil)
    m.AddField("*", "a.f")
    m.AddField("b.c", "")
    m.AddField("b.c[2] + b.c[3]", "b.a")
    m.AddField("CurrentTimestamp()", "b.b")

    rule.AddHandler(m)
    
    text := `
            {
                "a":1,
                "b":{
                        "c":[1,2,3,4,5]
                    },
                "c":"123456789",
                "e":{
                        "f":2
                    }
            }
            `
    jsonText, _ := rule.ConvertJson(text)
    
    fmt.Println(string(jsonText))
    /*	
        //output:
        {
            "a": {
                "a": 3,
                "b": "hello",
                "c": 15,
                "d": "3456789",
                "e": 1556611910,
                "f": {
                    "a": 1,
                    "b": {
                        "c": [
                            1,
                            2,
                            3,
                            4,
                            5
                        ]
                    },
                    "c": "123456789",
                    "e": {
                        "f": 2
                    }
                }
            },
            "b": {
                "a": 7,
                "b": 1556611910,
                "c": [
                    1,
                    2,
                    3,
                    4,
                    5
                ]
            }
        }
    */
    
    tm := time.Now()
    for i := 0; i < 10000; i ++  {
        _,_ = rule.ConvertJson(text)
    }
    fmt.Println( "time elapse:",time.Now().Sub(tm).Nanoseconds(),"ns")
    /*
        //output:
        time elapse: 4265625000 ns
    */

Supported golang operators

• logic : && || !
• number: + - * / % > < >= <= == != & | ^ >> <<
• string: + > < >= <= == !=
• array : [index]
• other : == !=

Supported golang constant

• nil

Supported other operators in sql

• = as ==
• and as &&
• or as ||
• not as !

Supported sql constant

• null as nil

Supported functions (case insensitive)

• sum(numberArray)
• sum(num1,num2,num3...)
• average(numberArray)
• average(num1,num2,num3...)
• len(array)
• min(numberArray)
• min(num1,num2,num3...)
• max(numberArray)
• max(num1,num2,num3...)
• array(val1,val2,val3...)
• substr(text,pos,length) : length is optional
• string(number)
• int(stringOrFloat)
• float(stringOrInt)
• timestamp(year,month,day,hour,minute,second)
• currenttimestamp()
• year(timestamp)
• month(timestamp)
• day(timestamp)
• hour(timestamp)
• minute(timestamp)
• second(timestamp)
• regex(text,pattern)
• in(value,array) : whether val is in array
• in(value,val1,val2,val3...) : whether val is one of val1,val2,val3...
• inrange(target,min,max) : whether target is between min and max.but if min > max, whether target >= min or target < right
• abs(number)
• exp(number)
• sqrt(number)
• power(numberX,numberY)
• ceil(number)
• floor(number)
• nullif(val,target) : return null if val==target,or val1
• ifnull(val) : return true if val is null,or false
• iif(condition,whenTrue,whenFalse) : return whenTrue when condition is true,or whenFalse

author

email: sdghchj@qq.com