Merge pull request #18 from influxdata/js-simplify-call-valuer

Simplify the call valuer to remove the influxql.Expr references

ast.go

@@ -3983,7 +3983,14 @@ func (v *ValuerEval) Eval(expr Expr) interface{} {
 		return expr.Val
 	case *Call:
 		if valuer, ok := v.Valuer.(CallValuer); ok {
-			val, _ := valuer.Call(expr.Name, expr.Args)
+			var args []interface{}
+			if len(expr.Args) > 0 {
+				args = make([]interface{}, len(expr.Args))
+				for i := range expr.Args {
+					args[i] = v.Eval(expr.Args[i])
+				}
+			}
+			val, _ := valuer.Call(expr.Name, args)
 			return val
 		}
 		return nil
@@ -5224,17 +5231,28 @@ func reduceBinaryExprTimeLHS(op Token, lhs *TimeLiteral, rhs Expr, loc *time.Loc
 func reduceCall(expr *Call, valuer Valuer) Expr {
 	// Otherwise reduce arguments.
 	var args []Expr
+	literalsOnly := true
 	if len(expr.Args) > 0 {
 		args = make([]Expr, len(expr.Args))
 		for i, arg := range expr.Args {
 			args[i] = reduce(arg, valuer)
+			if !isLiteral(args[i]) {
+				literalsOnly = false
+			}
 		}
 	}
 
-	// Evaluate a function call if the valuer is a CallValuer.
-	if valuer, ok := valuer.(CallValuer); ok {
-		if v, ok := valuer.Call(expr.Name, args); ok {
-			return asLiteral(v)
+	// Evaluate a function call if the valuer is a CallValuer and
+	// the arguments are only literals.
+	if literalsOnly {
+		if valuer, ok := valuer.(CallValuer); ok {
+			argVals := make([]interface{}, len(args))
+			for i := range args {
+				argVals[i] = Eval(args[i], nil)
+			}
+			if v, ok := valuer.Call(expr.Name, argVals); ok {
+				return asLiteral(v)
+			}
 		}
 	}
 	return &Call{Name: expr.Name, Args: args}
@@ -5302,7 +5320,7 @@ type CallValuer interface {
 	Valuer
 
 	// Call is invoked to evaluate a function call (if possible).
-	Call(name string, args []Expr) (interface{}, bool)
+	Call(name string, args []interface{}) (interface{}, bool)
 }
 
 // ZoneValuer is the interface that specifies the current time zone.
@@ -5314,6 +5332,9 @@ type ZoneValuer interface {
 	Zone() *time.Location
 }
 
+var _ CallValuer = (*NowValuer)(nil)
+var _ ZoneValuer = (*NowValuer)(nil)
+
 // NowValuer returns only the value for "now()".
 type NowValuer struct {
 	Now      time.Time
@@ -5329,7 +5350,7 @@ func (v *NowValuer) Value(key string) (interface{}, bool) {
 }
 
 // Call evaluates the now() function to replace now() with the current time.
-func (v *NowValuer) Call(name string, args []Expr) (interface{}, bool) {
+func (v *NowValuer) Call(name string, args []interface{}) (interface{}, bool) {
 	if name == "now" && len(args) == 0 {
 		return v.Now, true
 	}
@@ -5352,6 +5373,9 @@ func MultiValuer(valuers ...Valuer) Valuer {
 
 type multiValuer []Valuer
 
+var _ CallValuer = multiValuer(nil)
+var _ ZoneValuer = multiValuer(nil)
+
 func (a multiValuer) Value(key string) (interface{}, bool) {
 	for _, valuer := range a {
 		if v, ok := valuer.Value(key); ok {
@@ -5361,7 +5385,7 @@ func (a multiValuer) Value(key string) (interface{}, bool) {
 	return nil, false
 }
 
-func (a multiValuer) Call(name string, args []Expr) (interface{}, bool) {
+func (a multiValuer) Call(name string, args []interface{}) (interface{}, bool) {
 	for _, valuer := range a {
 		if valuer, ok := valuer.(CallValuer); ok {
 			if v, ok := valuer.Call(name, args); ok {

ast_test.go

@@ -3,6 +3,7 @@ package influxql_test
 import (
 	"fmt"
 	"go/importer"
+	"math"
 	"reflect"
 	"strings"
 	"testing"
@@ -43,8 +44,8 @@ func TestInspectDataType(t *testing.T) {
 }
 
 func TestDataTypeFromString(t *testing.T) {
-	for i, tt := range []struct{
-		s string
+	for i, tt := range []struct {
+		s   string
 		typ influxql.DataType
 	}{
 		{s: "float", typ: influxql.Float},
@@ -57,7 +58,7 @@ func TestDataTypeFromString(t *testing.T) {
 		{s: "tag", typ: influxql.Tag},
 		{s: "field", typ: influxql.AnyField},
 		{s: "foobar", typ: influxql.Unknown},
-	}{
+	} {
 		if typ := influxql.DataTypeFromString(tt.s); tt.typ != typ {
 			t.Errorf("%d. %s: unexpected type: %s != %s", i, tt.s, tt.typ, typ)
 		}
@@ -1839,3 +1840,44 @@ func BenchmarkExprNames(b *testing.B) {
 		}
 	}
 }
+
+type FunctionValuer struct{}
+
+var _ influxql.CallValuer = FunctionValuer{}
+
+func (FunctionValuer) Value(key string) (interface{}, bool) {
+	return nil, false
+}
+
+func (FunctionValuer) Call(name string, args []interface{}) (interface{}, bool) {
+	switch name {
+	case "abs":
+		arg0 := args[0].(float64)
+		return math.Abs(arg0), true
+	case "pow":
+		arg0, arg1 := args[0].(float64), args[1].(int64)
+		return math.Pow(arg0, float64(arg1)), true
+	default:
+		return nil, false
+	}
+}
+
+// BenchmarkEval benchmarks how long it takes to run Eval.
+func BenchmarkEval(b *testing.B) {
+	expr := MustParseExpr(`f1 + abs(f2) / pow(f3, 3)`)
+	valuer := influxql.ValuerEval{
+		Valuer: influxql.MultiValuer(
+			influxql.MapValuer(map[string]interface{}{
+				"f1": float64(15),
+				"f2": float64(-3),
+				"f3": float64(2),
+			}),
+			FunctionValuer{},
+		),
+	}
+
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		valuer.Eval(expr)
+	}
+}