get rule values in parallel

Author: LeandroSNunes

querybuilder/operator/equal_test.go

@@ -18,6 +18,8 @@ func TestEqual(t *testing.T) {
 		{value: 1.55, input: 1.56, want: false},
 	}
 
+	// testar nil
+
 	for _, input := range inputs {
 		got := Equal.Evaluate(input.value, input.input)
 		if got != input.want {

querybuilder/operator/operator.go

@@ -1,3 +1,4 @@
+// Operator package contains the operators used in rules
 // Reference: https://golang.org/ref/spec#Comparison_operators
 package operator
 
@@ -8,10 +9,13 @@ type Operator struct {
 
 var operators = make(map[string]*Operator)
 
+// AddOperator allow add operator in the operators collection
+// This method should be called in init function
 func AddOperator(opr *Operator) {
 	operators[opr.Name] = opr
 }
 
+// GetOperator get the operator by name
 func GetOperator(name string) (*Operator, bool) {
 	opr, ok := operators[name]
 	return opr, ok

querybuilder/rule.go

@@ -3,6 +3,7 @@ package querybuilder
 import (
 	"reflect"
 	"strings"
+	"sync"
 
 	"github.com/enjoei/pkg/querybuilder/operator"
 )
@@ -16,33 +17,57 @@ type Rule struct {
 	Value    interface{}
 }
 
+// Evaluate function checks whether the dataset matches with rule
 func (r *Rule) Evaluate(dataset map[string]interface{}) bool {
+	var wg sync.WaitGroup
+	var input, value interface{}
+
 	opr, ok := operator.GetOperator(r.Operator)
 	if !ok {
 		return false
 	}
 
-	return opr.Evaluate(r.getInputValue(dataset), r.getValue())
+	wg.Add(2)
+	go func() {
+		input = r.getInputValue(dataset)
+		wg.Done()
+	}()
+
+	go func() {
+		value = r.getValue()
+		wg.Done()
+	}()
+
+	wg.Wait()
+	return opr.Evaluate(input, value)
 }
 
 func (r *Rule) getValue() interface{} {
 	return r.parseValue(r.Value)
 }
 
 func (r *Rule) getInputValue(dataset map[string]interface{}) interface{} {
+	var rdataset = make(map[string]interface{})
 	var result interface{}
 	var ok bool
+
+	for k, v := range dataset {
+		rdataset[k] = v
+	}
+
 	field := strings.Split(r.Field, ".")
 	steps := len(field)
 
 	for i := 0; i < steps; i++ {
-		result, ok = dataset[field[i]]
+		result, ok = rdataset[field[i]]
 		if !ok {
 			return nil
 		}
 
 		rresult := reflect.ValueOf(result)
-		if rresult.Kind() == reflect.Slice && i != (steps-1) {
+		if rresult.Kind() == reflect.Map {
+			rdataset = result.(map[string]interface{})
+		} else if rresult.Kind() == reflect.Slice && i != (steps-1) {
 			result = rresult.Index(0)
 		}
 

querybuilder/rule_test.go

@@ -8,17 +8,17 @@ func TestRuleEvaluate(t *testing.T) {
 		want bool
 	}{
 		{&Rule{ID: "float_equal", Field: "float_equal", Type: "double", Input: "text", Operator: "equal", Value: 1.2}, true},
-		{&Rule{ID: "float_equal_f", Field: "float_equal_f", Type: "double", Input: "text", Operator: "equal", Value: 1.3}, false},
+		{&Rule{ID: "float_equal_f", Field: "float_equal", Type: "double", Input: "text", Operator: "equal", Value: 1.3}, false},
+		{&Rule{ID: "float_field_equal", Field: "float_field.equal", Type: "double", Input: "text", Operator: "equal", Value: 3.7}, true},
 		{&Rule{ID: "int_greater", Field: "int_greater", Type: "integer", Input: "text", Operator: "greater", Value: 1.0}, true},
-		{&Rule{ID: "int_greater_f", Field: "int_greater_f", Type: "integer", Input: "text", Operator: "greater", Value: 3.0}, false},
+		{&Rule{ID: "int_greater_f", Field: "int_greater", Type: "integer", Input: "text", Operator: "greater", Value: 3.0}, false},
 		{&Rule{ID: "int_not_field", Field: "int_not_field", Type: "integer", Input: "text", Operator: "greater", Value: 2.0}, false},
 	}
 
 	dataset := map[string]interface{}{
-		"float_equal":   1.2,
-		"float_equal_f": 1.2,
-		"int_greater":   2.0,
-		"int_greater_f": 2.0,
+		"float_equal": 1.2,
+		"int_greater": 2.0,
+		"float_field": map[string]interface{}{"equal": 3.7, "greater": 5.0},
 	}
 
 	for _, i := range inputs {