types: add go native conversion methods to several types

Addresses IDX-416

Signed-off-by: philhassey <[email protected]>

internal/error.go

@@ -11,3 +11,4 @@ var ErrDecimal = fmt.Errorf("error parsing decimal value")
 var ErrDuration = fmt.Errorf("error parsing duration value")
 var ErrIP = fmt.Errorf("error parsing ip value")
 var ErrNotComparable = fmt.Errorf("incompatible types in comparison")
+var ErrDurationRange = fmt.Errorf("duration out of range")

types/datetime.go

@@ -274,6 +274,11 @@ func (a Datetime) Milliseconds() int64 {
 	return a.value
 }
 
+// Time returns the time.Time representation of a Datetime.
+func (a Datetime) Time() time.Time {
+	return time.UnixMilli(a.value)
+}
+
 func (v Datetime) hash() uint64 {
 	return uint64(v.value)
 }

types/datetime_test.go

@@ -119,6 +119,14 @@ func TestDatetime(t *testing.T) {
 		testutil.Equals(t, one.Milliseconds(), two.Milliseconds())
 	})
 
+	t.Run("Time", func(t *testing.T) {
+		t.Parallel()
+		in := types.NewDatetime(time.UnixMilli(42))
+		got := in.Time()
+		want := time.UnixMilli(42)
+		testutil.Equals(t, got, want)
+	})
+
 	t.Run("Equal", func(t *testing.T) {
 		t.Parallel()
 		one := types.NewDatetimeFromMillis(1)

types/decimal.go

@@ -186,6 +186,12 @@ func (d Decimal) MarshalJSON() ([]byte, error) {
 	})
 }
 
+// Float returns a float64 representation of a Decimal.  Warning: some precision
+// may be lost during this conversion.
+func (d Decimal) Float() float64 {
+	return float64(d.value)/decimalPrecision
+}
+
 func (d Decimal) hash() uint64 {
 	return uint64(d.value)
 }

types/decimal_test.go

@@ -281,6 +281,15 @@ func TestDecimal(t *testing.T) {
 		}
 	})
 
+	t.Run("Float", func(t *testing.T) {
+		t.Parallel()
+		in, err := types.NewDecimalFromFloat(42.42)
+		testutil.OK(t, err)
+		got := in.Float()
+		want := 42.42
+		testutil.Equals(t, got, want)
+	})
+
 	t.Run("MarshalCedar", func(t *testing.T) {
 		t.Parallel()
 		testutil.Equals(

types/duration.go

@@ -267,6 +267,18 @@ func (v Duration) ToMilliseconds() int64 {
 	return v.value
 }
 
+// Duration returns a time.Duration representation of a Duration.  An error
+// is returned if the duration cannot be converted to a time.Duration.
+func (v Duration) Duration() (time.Duration, error) {
+	if v.value > math.MaxInt64/1000 {
+		return 0, internal.ErrDurationRange
+	}
+	if v.value < math.MinInt64/1000 {
+		return 0, internal.ErrDurationRange
+	}
+	return time.Millisecond * time.Duration(v.value), nil
+}
+
 func (v Duration) hash() uint64 {
 	return uint64(v.value)
 }

types/duration_test.go

@@ -3,6 +3,7 @@ package types_test
 import (
 	"encoding/json"
 	"fmt"
+	"math"
 	"testing"
 	"time"
 
@@ -87,6 +88,29 @@ func TestDuration(t *testing.T) {
 		testutil.Equals(t, one.ToMilliseconds(), two.ToMilliseconds())
 	})
 
+	t.Run("Duration", func(t *testing.T) {
+		t.Parallel()
+		tests := []struct {
+			name string
+			in   types.Duration
+			out  time.Duration
+			err  func(testutil.TB, error)
+		}{
+			{"ok", types.NewDuration(time.Millisecond * 42), time.Millisecond * 42, testutil.OK},
+			{"maxPlusOne", types.NewDurationFromMillis(math.MaxInt64/1000 + 1), 0, testutil.Error},
+			{"minMinusOne", types.NewDurationFromMillis(math.MinInt64/1000 - 1), 0, testutil.Error},
+		}
+		for _, tt := range tests {
+			tt := tt
+			t.Run(tt.name, func(t *testing.T) {
+				t.Parallel()
+				out, err := tt.in.Duration()
+				testutil.Equals(t, out, tt.out)
+				tt.err(t, err)
+			})
+		}
+	})
+
 	t.Run("Equal", func(t *testing.T) {
 		t.Parallel()
 		one := types.NewDurationFromMillis(1)