Intermediate migration to new value types

Author: sudhirj

geo.go

@@ -15,60 +15,60 @@ import (
 const earthRadiusMeters = 6372797.560856
 const skGeoCell = skN1
 
-type Location struct {
+type GLocation struct {
 	Lat float64
 	Lon float64
 }
 
-func (l Location) s2CellID() string {
+func (l GLocation) s2CellID() string {
 	return fmt.Sprintf("%d", s2.CellIDFromLatLng(l.s2LatLng()))
 }
 
-func (l Location) Geohash() string {
+func (l GLocation) Geohash() string {
 	return geohash.Encode(l.Lat, l.Lon)
 }
 
-func (l Location) toAV() dynamodb.AttributeValue {
+func (l GLocation) toAV() dynamodb.AttributeValue {
 	return dynamodb.AttributeValue{
 		N: aws.String(l.s2CellID()),
 	}
 }
 
-func (l *Location) setCellIDString(cellIDStr string) {
+func (l *GLocation) setCellIDString(cellIDStr string) {
 	cellID, _ := strconv.ParseUint(cellIDStr, 10, 64)
 	s2Cell := s2.CellID(cellID)
 	s2LatLon := s2Cell.LatLng()
 	l.Lat = s2LatLon.Lat.Degrees()
 	l.Lon = s2LatLon.Lng.Degrees()
 }
 
-func (l Location) DistanceTo(other Location, unit Unit) float64 {
+func (l GLocation) DistanceTo(other GLocation, unit GUnit) (distance float64) {
 	return Meters.To(unit, l.s2LatLng().Distance(other.s2LatLng()).Radians()*earthRadiusMeters)
 }
 
-func (l Location) s2LatLng() s2.LatLng {
+func (l GLocation) s2LatLng() s2.LatLng {
 	return s2.LatLngFromDegrees(l.Lat, l.Lon)
 }
 
-func fromCellIDString(cellID string) (l Location) {
+func fromCellIDString(cellID string) (l GLocation) {
 	l.setCellIDString(cellID)
 	return
 }
 
-type Unit float64
+type GUnit float64
 
-func (from Unit) To(to Unit, d float64) float64 {
+func (from GUnit) To(to GUnit, d float64) float64 {
 	return (d / float64(to)) * float64(from)
 }
 
 const (
-	Meters     Unit = 1.0
-	Kilometers Unit = 1000.0
-	Miles      Unit = 1609.34
-	Feet       Unit = 0.3048
+	Meters     GUnit = 1.0
+	Kilometers GUnit = 1000.0
+	Miles      GUnit = 1609.34
+	Feet       GUnit = 0.3048
 )
 
-func (c Client) GEOADD(key string, members map[string]Location) (addedCount int64, err error) {
+func (c Client) GEOADD(key string, members map[string]GLocation) (addedCount int64, err error) {
 	for member, location := range members {
 		builder := newExpresionBuilder()
 		builder.updateSetAV(skGeoCell, location.toAV())
@@ -90,7 +90,7 @@ func (c Client) GEOADD(key string, members map[string]Location) (addedCount int6
 	return addedCount, nil
 }
 
-func (c Client) GEODIST(key string, member1, member2 string, unit Unit) (distance float64, ok bool, err error) {
+func (c Client) GEODIST(key string, member1, member2 string, unit GUnit) (distance float64, ok bool, err error) {
 	locations, err := c.GEOPOS(key, member1, member2)
 	if err != nil || len(locations) < 2 {
 		return
@@ -113,8 +113,8 @@ func (c Client) GEOHASH(key string, members ...string) (geohashes []string, err
 	return
 }
 
-func (c Client) GEOPOS(key string, members ...string) (locations map[string]Location, err error) {
-	locations = make(map[string]Location)
+func (c Client) GEOPOS(key string, members ...string) (locations map[string]GLocation, err error) {
+	locations = make(map[string]GLocation)
 
 	for _, member := range members {
 		resp, err := c.ddbClient.GetItemRequest(&dynamodb.GetItemInput{
@@ -135,8 +135,8 @@ func (c Client) GEOPOS(key string, members ...string) (locations map[string]Loca
 	return
 }
 
-func (c Client) GEORADIUS(key string, center Location, radius float64, radiusUnit Unit, count int64) (positions map[string]Location, err error) {
-	positions = make(map[string]Location)
+func (c Client) GEORADIUS(key string, center GLocation, radius float64, radiusUnit GUnit, count int64) (positions map[string]GLocation, err error) {
+	positions = make(map[string]GLocation)
 	radiusCap := s2.CapFromCenterAngle(s2.PointFromLatLng(center.s2LatLng()), s1.Angle(radiusUnit.To(Meters, radius)/earthRadiusMeters))
 
 	for _, cellID := range radiusCap.CellUnionBound() {
@@ -186,7 +186,7 @@ func (c Client) GEORADIUS(key string, center Location, radius float64, radiusUni
 	return
 }
 
-func (c Client) GEORADIUSBYMEMBER(key string, member string, radius float64, radiusUnit Unit, count int64) (positions map[string]Location, err error) {
+func (c Client) GEORADIUSBYMEMBER(key string, member string, radius float64, radiusUnit GUnit, count int64) (positions map[string]GLocation, err error) {
 	locations, err := c.GEOPOS(key, member)
 	if err == nil {
 		positions, err = c.GEORADIUS(key, locations[member], radius, radiusUnit, count)

geo_test.go

@@ -8,7 +8,7 @@ import (
 )
 
 func TestPointsAndDistances(t *testing.T) {
-	l := Location{
+	l := GLocation{
 		Lat: 38.115556,
 		Lon: 13.361389,
 	}
@@ -21,7 +21,7 @@ func TestPointsAndDistances(t *testing.T) {
 
 func TestGeoBasics(t *testing.T) {
 	c := newClient(t)
-	startingMap := map[string]Location{
+	startingMap := map[string]GLocation{
 		"Palermo": {38.115556, 13.361389},
 		"Catania": {37.502669, 15.087269},
 	}
@@ -63,7 +63,7 @@ func TestGeoBasics(t *testing.T) {
 
 func TestGeoRadius(t *testing.T) {
 	c := newClient(t)
-	_, err := c.GEOADD("india", map[string]Location{
+	_, err := c.GEOADD("india", map[string]GLocation{
 		"chennai":    {13.09, 80.28},
 		"vellore":    {12.9204, 79.15},
 		"pondy":      {11.935, 79.83},
@@ -73,7 +73,7 @@ func TestGeoRadius(t *testing.T) {
 	})
 	assert.NoError(t, err)
 
-	locations, err := c.GEORADIUS("india", Location{13.09, 80.28}, 180, Kilometers, 10)
+	locations, err := c.GEORADIUS("india", GLocation{13.09, 80.28}, 180, Kilometers, 10)
 	assert.NoError(t, err)
 	assert.Equal(t, 3, len(locations))
 	assert.InDelta(t, locations["chennai"].Lat, 13.09, 0.1)

hashes.go

@@ -2,14 +2,14 @@ package redimo
 
 import (
 	"context"
-	"math/big"
+	"log"
 	"strings"
 
 	"github.com/aws/aws-sdk-go-v2/aws"
 	"github.com/aws/aws-sdk-go-v2/service/dynamodb"
 )
 
-func (c Client) HGET(key string, field string) (val Value, err error) {
+func (c Client) HGET(key string, field string) (val ReturnValue, err error) {
 	resp, err := c.ddbClient.GetItemRequest(&dynamodb.GetItemInput{
 		ConsistentRead: aws.Bool(c.consistentReads),
 		Key: keyDef{
@@ -34,7 +34,7 @@ func (c Client) HSET(key string, fieldValues map[string]Value) (savedCount int64
 			PutRequest: &dynamodb.PutRequest{
 				Item: itemDef{
 					keyDef: keyDef{pk: key, sk: field},
-					val:    v,
+					val:    ReturnValue{v.ToAV()},
 				}.eav(),
 			},
 		})
@@ -90,7 +90,7 @@ func (c Client) HMSET(key string, fieldValues map[string]Value) (err error) {
 	return
 }
 
-func (c Client) HMGET(key string, fields ...string) (values []Value, err error) {
+func (c Client) HMGET(key string, fields ...string) (values []ReturnValue, err error) {
 	items := make([]dynamodb.TransactGetItem, len(fields))
 	for i, field := range fields {
 		items[i] = dynamodb.TransactGetItem{Get: &dynamodb.Get{
@@ -162,8 +162,8 @@ func (c Client) HEXISTS(key string, field string) (exists bool, err error) {
 	return
 }
 
-func (c Client) HGETALL(key string) (fieldValues map[string]Value, err error) {
-	fieldValues = make(map[string]Value)
+func (c Client) HGETALL(key string) (fieldValues map[string]ReturnValue, err error) {
+	fieldValues = make(map[string]ReturnValue)
 	hasMoreResults := true
 
 	var lastEvaluatedKey map[string]dynamodb.AttributeValue
@@ -200,13 +200,22 @@ func (c Client) HGETALL(key string) (fieldValues map[string]Value, err error) {
 	return
 }
 
-func (c Client) HINCRBYFLOAT(key string, field string, delta *big.Float) (after *big.Float, err error) {
+func (c Client) HINCRBYFLOAT(key string, field string, delta float64) (after float64, err error) {
+	rv, err := c.hIncr(key, field, FloatValue{delta})
+	if err == nil {
+		after = rv.Float()
+	}
+
+	return
+}
+
+func (c Client) hIncr(key string, field string, delta Value) (after ReturnValue, err error) {
 	builder := newExpresionBuilder()
 	builder.keys[vk] = struct{}{}
 	resp, err := c.ddbClient.UpdateItemRequest(&dynamodb.UpdateItemInput{
 		ExpressionAttributeNames: builder.expressionAttributeNames(),
 		ExpressionAttributeValues: map[string]dynamodb.AttributeValue{
-			":delta": NumericValue{delta}.toAV(),
+			":delta": delta.ToAV(),
 		},
 		Key:              keyDef{pk: key, sk: field}.toAV(),
 		ReturnValues:     dynamodb.ReturnValueAllNew,
@@ -215,19 +224,19 @@ func (c Client) HINCRBYFLOAT(key string, field string, delta *big.Float) (after
 	}).Send(context.TODO())
 
 	if err == nil {
-		after, _ = parseItem(resp.UpdateItemOutput.Attributes).val.AsNumeric()
+		after = ReturnValue{resp.UpdateItemOutput.Attributes[vk]}
 	}
 
 	return
 }
 
-func (c Client) HINCRBY(key string, field string, delta *big.Int) (after *big.Int, err error) {
-	afterFloat, err := c.HINCRBYFLOAT(key, field, new(big.Float).SetInt(delta))
-	if err != nil {
-		return
-	}
+func (c Client) HINCRBY(key string, field string, delta int64) (after int64, err error) {
+	rv, err := c.hIncr(key, field, IntValue{delta})
+	log.Println(aws.StringValue(rv.AV.N))
 
-	after, _ = afterFloat.Int(nil)
+	if err == nil {
+		after = rv.Int()
+	}
 
 	return
 }
@@ -271,7 +280,7 @@ func (c Client) HKEYS(key string) (keys []string, err error) {
 	return
 }
 
-func (c Client) HVALS(key string) (values []Value, err error) {
+func (c Client) HVALS(key string) (values []ReturnValue, err error) {
 	all, err := c.HGETALL(key)
 	if err == nil {
 		for _, v := range all {

hashes_test.go

@@ -1,7 +1,6 @@
 package redimo
 
 import (
-	"math/big"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -15,31 +14,32 @@ func TestBasicHashes(t *testing.T) {
 
 	val, err := c.HGET("k1", "f1")
 	assert.NoError(t, err)
-	assert.Equal(t, StringValue{"v1"}, val)
+	assert.Equal(t, "v1", val.String())
 
 	val, err = c.HGET("k1", "f2")
 	assert.NoError(t, err)
-	assert.Equal(t, StringValue{"v2"}, val)
+	assert.Equal(t, "v2", val.String())
 
 	exists, err := c.HEXISTS("k1", "f2")
 	assert.NoError(t, err)
 	assert.True(t, exists)
 
 	val, err = c.HGET("nosuchkey", "no such field")
 	assert.NoError(t, err)
-	assert.Nil(t, val)
+	assert.True(t, val.Empty())
 
 	keyValues, err := c.HGETALL("k1")
 	assert.NoError(t, err)
-	assert.Equal(t, map[string]Value{"f1": StringValue{"v1"}, "f2": StringValue{"v2"}}, keyValues)
+	assert.Len(t, keyValues, 2)
+	assert.Equal(t, map[string]ReturnValue{"f1": {StringValue{"v1"}.ToAV()}, "f2": {StringValue{"v2"}.ToAV()}}, keyValues)
 
 	keys, err := c.HKEYS("k1")
 	assert.NoError(t, err)
 	assert.ElementsMatch(t, []string{"f1", "f2"}, keys)
 
 	vals, err := c.HVALS("k1")
 	assert.NoError(t, err)
-	assert.ElementsMatch(t, []Value{StringValue{"v1"}, StringValue{"v2"}}, vals)
+	assert.ElementsMatch(t, []ReturnValue{{StringValue{"v1"}.ToAV()}, {StringValue{"v2"}.ToAV()}}, vals)
 
 	count, err := c.HLEN("k1")
 	assert.NoError(t, err)
@@ -50,11 +50,11 @@ func TestBasicHashes(t *testing.T) {
 
 	val, err = c.HGET("k1", "f2")
 	assert.NoError(t, err)
-	assert.Nil(t, val)
+	assert.True(t, val.Empty())
 
 	val, err = c.HGET("k1", "f1")
 	assert.NoError(t, err)
-	assert.Nil(t, val)
+	assert.True(t, val.Empty())
 
 	exists, err = c.HEXISTS("k1", "f1")
 	assert.NoError(t, err)
@@ -80,15 +80,16 @@ func TestAtomicHashOps(t *testing.T) {
 
 	val, err := c.HGET("k1", "f1")
 	assert.NoError(t, err)
-	assert.Equal(t, StringValue{"v1"}, val)
+	assert.Equal(t, "v1", val.String())
 
 	val, err = c.HGET("k1", "f2")
 	assert.NoError(t, err)
-	assert.Equal(t, StringValue{"v2"}, val)
+	assert.Equal(t, "v2", val.String())
 
 	values, err := c.HMGET("k1", "f1", "f2")
 	assert.NoError(t, err)
-	assert.Equal(t, []Value{StringValue{"v1"}, StringValue{"v2"}}, values)
+	assert.Len(t, values, 2)
+	assert.Equal(t, []string{"v1", "v2"}, []string{values[0].String(), values[1].String()})
 
 	ok, err := c.HSETNX("k1", "f1", StringValue{"v1"})
 	assert.NoError(t, err)
@@ -100,42 +101,33 @@ func TestAtomicHashOps(t *testing.T) {
 
 	val, err = c.HGET("k1", "f9")
 	assert.NoError(t, err)
-	assert.Equal(t, StringValue{"v9"}, val)
+	assert.Equal(t, "v9", val.String())
 }
 
 func TestHashCounters(t *testing.T) {
 	c := newClient(t)
 
-	after, err := c.HINCRBYFLOAT("k1", "f1", big.NewFloat(3.14))
+	after, err := c.HINCRBYFLOAT("k1", "f1", 3.14)
 	assert.NoError(t, err)
+	assert.InDelta(t, 3.14, after, 0.001)
 
-	f, _ := after.Float64()
-	assert.InDelta(t, 3.14, f, 0.001)
-
-	after, err = c.HINCRBYFLOAT("k1", "f1", big.NewFloat(-1.618))
+	after, err = c.HINCRBYFLOAT("k1", "f1", -1.618)
 	assert.NoError(t, err)
+	assert.InDelta(t, 1.522, after, 0.001)
 
-	f, _ = after.Float64()
-	assert.InDelta(t, 1.522, f, 0.001)
-
-	afterInt, err := c.HINCRBY("k1", "f1", big.NewInt(42))
+	afterInt, err := c.HINCRBY("k1", "f1", 42)
 	assert.NoError(t, err)
-	assert.Equal(t, int64(43), afterInt.Int64())
+	assert.Equal(t, int64(43), afterInt)
 
-	afterInt, err = c.HINCRBY("k1", "f1", big.NewInt(-13))
+	afterInt, err = c.HINCRBY("k1", "f1", -13)
 	assert.NoError(t, err)
-	assert.Equal(t, int64(30), afterInt.Int64())
+	assert.Equal(t, int64(30), afterInt)
 
-	afterInt, err = c.HINCRBY("k1", "f2", big.NewInt(42))
+	afterInt, err = c.HINCRBY("k1", "f2", 42)
 	assert.NoError(t, err)
-	assert.Equal(t, int64(42), afterInt.Int64())
+	assert.Equal(t, int64(42), afterInt)
 
 	v, err := c.HGET("k1", "f2")
 	assert.NoError(t, err)
-
-	nval, ok := v.AsNumeric()
-	assert.True(t, ok)
-
-	n, _ := nval.Int64()
-	assert.Equal(t, n, int64(42))
+	assert.Equal(t, int64(42), v.Int())
 }