From b2571883cae4290b4ef0dd0a583d22c14116c4a3 Mon Sep 17 00:00:00 2001 From: Kevin Wan Date: Fri, 13 Jan 2023 14:04:37 +0800 Subject: [PATCH] chore: refactor (#2785) * chore: refactor * chore: refactor --- core/stores/redis/redis.go | 100 ++++++++++++++++++-------------- core/stores/redis/redis_test.go | 26 ++++----- 2 files changed, 71 insertions(+), 55 deletions(-) diff --git a/core/stores/redis/redis.go b/core/stores/redis/redis.go index 3eba78a0..1be6a7c3 100644 --- a/core/stores/redis/redis.go +++ b/core/stores/redis/redis.go @@ -42,10 +42,12 @@ type ( Score int64 } - PairFloat struct { + // A FloatPair is a key/pair for float set used in redis zet. + FloatPair struct { Key string Score float64 } + // Redis defines a redis node/cluster. It is thread-safe. Redis struct { Addr string @@ -1002,6 +1004,7 @@ func (s *Redis) IncrCtx(ctx context.Context, key string) (val int64, err error) return } + // Incrby is the implementation of redis incrby command. func (s *Redis) Incrby(key string, increment int64) (int64, error) { return s.IncrbyCtx(context.Background(), key, increment) @@ -1021,6 +1024,7 @@ func (s *Redis) IncrbyCtx(ctx context.Context, key string, increment int64) (val return } + // Incrby is the implementation of redis incrby command. func (s *Redis) IncrbyFloat(key string, increment float64) (float64, error) { return s.IncrbyFloatCtx(context.Background(), key, increment) @@ -1040,6 +1044,7 @@ func (s *Redis) IncrbyFloatCtx(ctx context.Context, key string, increment float6 return } + // Keys is the implementation of redis keys command. func (s *Redis) Keys(pattern string) ([]string, error) { return s.KeysCtx(context.Background(), pattern) @@ -2247,13 +2252,13 @@ func (s *Redis) ZrangeWithScoresCtx(ctx context.Context, key string, start, stop } // ZrangeWithScoresByFloat is the implementation of redis zrange command with scores by float64. -func (s *Redis) ZrangeWithScoresByFloat(key string, start, stop int64) ([]PairFloat, error) { +func (s *Redis) ZrangeWithScoresByFloat(key string, start, stop int64) ([]FloatPair, error) { return s.ZrangeWithScoresByFloatCtx(context.Background(), key, start, stop) } // ZrangeWithScoresByFloatCtx is the implementation of redis zrange command with scores by float64. func (s *Redis) ZrangeWithScoresByFloatCtx(ctx context.Context, key string, start, stop int64) ( - val []PairFloat, err error) { + val []FloatPair, err error) { err = s.brk.DoWithAcceptable(func() error { conn, err := getRedis(s) if err != nil { @@ -2265,7 +2270,7 @@ func (s *Redis) ZrangeWithScoresByFloatCtx(ctx context.Context, key string, star return err } - val = toPairsByFloat(v) + val = toFloatPairs(v) return nil }, acceptable) @@ -2299,13 +2304,13 @@ func (s *Redis) ZRevRangeWithScoresCtx(ctx context.Context, key string, start, s } // ZRevRangeWithScoresByFloat is the implementation of redis zrevrange command with scores by float. -func (s *Redis) ZRevRangeWithScoresByFloat(key string, start, stop int64) ([]PairFloat, error) { +func (s *Redis) ZRevRangeWithScoresByFloat(key string, start, stop int64) ([]FloatPair, error) { return s.ZRevRangeWithScoresByFloatCtx(context.Background(), key, start, stop) } // ZRevRangeWithScoresByFloatCtx is the implementation of redis zrevrange command with scores by float. func (s *Redis) ZRevRangeWithScoresByFloatCtx(ctx context.Context, key string, start, stop int64) ( - val []PairFloat, err error) { + val []FloatPair, err error) { err = s.brk.DoWithAcceptable(func() error { conn, err := getRedis(s) if err != nil { @@ -2317,7 +2322,7 @@ func (s *Redis) ZRevRangeWithScoresByFloatCtx(ctx context.Context, key string, s return err } - val = toPairsByFloat(v) + val = toFloatPairs(v) return nil }, acceptable) @@ -2354,13 +2359,13 @@ func (s *Redis) ZrangebyscoreWithScoresCtx(ctx context.Context, key string, star } // ZrangebyscoreWithScoresByFloat is the implementation of redis zrangebyscore command with scores by float. -func (s *Redis) ZrangebyscoreWithScoresByFloat(key string, start, stop float64) ([]PairFloat, error) { +func (s *Redis) ZrangebyscoreWithScoresByFloat(key string, start, stop float64) ([]FloatPair, error) { return s.ZrangebyscoreWithScoresByFloatCtx(context.Background(), key, start, stop) } // ZrangebyscoreWithScoresByFloatCtx is the implementation of redis zrangebyscore command with scores by float. func (s *Redis) ZrangebyscoreWithScoresByFloatCtx(ctx context.Context, key string, start, stop float64) ( - val []PairFloat, err error) { + val []FloatPair, err error) { err = s.brk.DoWithAcceptable(func() error { conn, err := getRedis(s) if err != nil { @@ -2368,14 +2373,14 @@ func (s *Redis) ZrangebyscoreWithScoresByFloatCtx(ctx context.Context, key strin } v, err := conn.ZRangeByScoreWithScores(ctx, key, &red.ZRangeBy{ - Min: fmt.Sprintf("%v", start), - Max: fmt.Sprintf("%v", stop), + Min: strconv.FormatFloat(start, 'f', -1, 64), + Max: strconv.FormatFloat(stop, 'f', -1, 64), }).Result() if err != nil { return err } - val = toPairsByFloat(v) + val = toFloatPairs(v) return nil }, acceptable) @@ -2423,14 +2428,15 @@ func (s *Redis) ZrangebyscoreWithScoresAndLimitCtx(ctx context.Context, key stri // ZrangebyscoreWithScoresByFloatAndLimit is the implementation of redis zrangebyscore command // with scores by float and limit. func (s *Redis) ZrangebyscoreWithScoresByFloatAndLimit(key string, start, stop float64, - page, size int) ([]PairFloat, error) { - return s.ZrangebyscoreWithScoresByFloatAndLimitCtx(context.Background(), key, start, stop, page, size) + page, size int) ([]FloatPair, error) { + return s.ZrangebyscoreWithScoresByFloatAndLimitCtx(context.Background(), + key, start, stop, page, size) } // ZrangebyscoreWithScoresByFloatAndLimitCtx is the implementation of redis zrangebyscore command // with scores by float and limit. func (s *Redis) ZrangebyscoreWithScoresByFloatAndLimitCtx(ctx context.Context, key string, start, - stop float64, page, size int) (val []PairFloat, err error) { + stop float64, page, size int) (val []FloatPair, err error) { err = s.brk.DoWithAcceptable(func() error { if size <= 0 { return nil @@ -2442,8 +2448,8 @@ func (s *Redis) ZrangebyscoreWithScoresByFloatAndLimitCtx(ctx context.Context, k } v, err := conn.ZRangeByScoreWithScores(ctx, key, &red.ZRangeBy{ - Min: fmt.Sprintf("%v", start), - Max: fmt.Sprintf("%v", stop), + Min: strconv.FormatFloat(start, 'f', -1, 64), + Max: strconv.FormatFloat(stop, 'f', -1, 64), Offset: int64(page * size), Count: int64(size), }).Result() @@ -2451,7 +2457,7 @@ func (s *Redis) ZrangebyscoreWithScoresByFloatAndLimitCtx(ctx context.Context, k return err } - val = toPairsByFloat(v) + val = toFloatPairs(v) return nil }, acceptable) @@ -2509,13 +2515,14 @@ func (s *Redis) ZrevrangebyscoreWithScoresCtx(ctx context.Context, key string, s } // ZrevrangebyscoreWithScoresByFloat is the implementation of redis zrevrangebyscore command with scores by float. -func (s *Redis) ZrevrangebyscoreWithScoresByFloat(key string, start, stop float64) ([]PairFloat, error) { +func (s *Redis) ZrevrangebyscoreWithScoresByFloat(key string, start, stop float64) ( + []FloatPair, error) { return s.ZrevrangebyscoreWithScoresByFloatCtx(context.Background(), key, start, stop) } // ZrevrangebyscoreWithScoresByFloatCtx is the implementation of redis zrevrangebyscore command with scores by float. -func (s *Redis) ZrevrangebyscoreWithScoresByFloatCtx(ctx context.Context, key string, start, stop float64) ( - val []PairFloat, err error) { +func (s *Redis) ZrevrangebyscoreWithScoresByFloatCtx(ctx context.Context, key string, + start, stop float64) (val []FloatPair, err error) { err = s.brk.DoWithAcceptable(func() error { conn, err := getRedis(s) if err != nil { @@ -2523,14 +2530,14 @@ func (s *Redis) ZrevrangebyscoreWithScoresByFloatCtx(ctx context.Context, key st } v, err := conn.ZRevRangeByScoreWithScores(ctx, key, &red.ZRangeBy{ - Min: fmt.Sprintf("%v", start), - Max: fmt.Sprintf("%v", stop), + Min: strconv.FormatFloat(start, 'f', -1, 64), + Max: strconv.FormatFloat(stop, 'f', -1, 64), }).Result() if err != nil { return err } - val = toPairsByFloat(v) + val = toFloatPairs(v) return nil }, acceptable) @@ -2541,7 +2548,8 @@ func (s *Redis) ZrevrangebyscoreWithScoresByFloatCtx(ctx context.Context, key st // with scores and limit. func (s *Redis) ZrevrangebyscoreWithScoresAndLimit(key string, start, stop int64, page, size int) ([]Pair, error) { - return s.ZrevrangebyscoreWithScoresAndLimitCtx(context.Background(), key, start, stop, page, size) + return s.ZrevrangebyscoreWithScoresAndLimitCtx(context.Background(), + key, start, stop, page, size) } // ZrevrangebyscoreWithScoresAndLimitCtx is the implementation of redis zrevrangebyscore command @@ -2578,14 +2586,15 @@ func (s *Redis) ZrevrangebyscoreWithScoresAndLimitCtx(ctx context.Context, key s // ZrevrangebyscoreWithScoresByFloatAndLimit is the implementation of redis zrevrangebyscore command // with scores by float and limit. func (s *Redis) ZrevrangebyscoreWithScoresByFloatAndLimit(key string, start, stop float64, - page, size int) ([]PairFloat, error) { - return s.ZrevrangebyscoreWithScoresByFloatAndLimitCtx(context.Background(), key, start, stop, page, size) + page, size int) ([]FloatPair, error) { + return s.ZrevrangebyscoreWithScoresByFloatAndLimitCtx(context.Background(), + key, start, stop, page, size) } // ZrevrangebyscoreWithScoresByFloatAndLimitCtx is the implementation of redis zrevrangebyscore command // with scores by float and limit. func (s *Redis) ZrevrangebyscoreWithScoresByFloatAndLimitCtx(ctx context.Context, key string, - start, stop float64, page, size int) (val []PairFloat, err error) { + start, stop float64, page, size int) (val []FloatPair, err error) { err = s.brk.DoWithAcceptable(func() error { if size <= 0 { return nil @@ -2597,8 +2606,8 @@ func (s *Redis) ZrevrangebyscoreWithScoresByFloatAndLimitCtx(ctx context.Context } v, err := conn.ZRevRangeByScoreWithScores(ctx, key, &red.ZRangeBy{ - Min: fmt.Sprintf("%v", start), - Max: fmt.Sprintf("%v", stop), + Min: strconv.FormatFloat(start, 'f', -1, 64), + Max: strconv.FormatFloat(stop, 'f', -1, 64), Offset: int64(page * size), Count: int64(size), }).Result() @@ -2606,7 +2615,7 @@ func (s *Redis) ZrevrangebyscoreWithScoresByFloatAndLimitCtx(ctx context.Context return err } - val = toPairsByFloat(v) + val = toFloatPairs(v) return nil }, acceptable) @@ -2713,37 +2722,44 @@ func toPairs(vals []red.Z) []Pair { } return pairs } -func toPairsByFloat(vals []red.Z) []PairFloat { - pairs := make([]PairFloat, len(vals)) + +func toFloatPairs(vals []red.Z) []FloatPair { + pairs := make([]FloatPair, len(vals)) + for i, val := range vals { switch member := val.Member.(type) { case string: - pairs[i] = PairFloat{ + pairs[i] = FloatPair{ Key: member, Score: val.Score, } default: - pairs[i] = PairFloat{ + pairs[i] = FloatPair{ Key: mapping.Repr(val.Member), Score: val.Score, } } } + return pairs } + func toStrings(vals []interface{}) []string { ret := make([]string, len(vals)) + for i, val := range vals { if val == nil { ret[i] = "" - } else { - switch val := val.(type) { - case string: - ret[i] = val - default: - ret[i] = mapping.Repr(val) - } + continue + } + + switch val := val.(type) { + case string: + ret[i] = val + default: + ret[i] = mapping.Repr(val) } } + return ret } diff --git a/core/stores/redis/redis_test.go b/core/stores/redis/redis_test.go index 3e428655..d48630f7 100644 --- a/core/stores/redis/redis_test.go +++ b/core/stores/redis/redis_test.go @@ -1021,7 +1021,7 @@ func TestRedis_SortedSetByFloat64(t *testing.T) { assert.NotNil(t, err) pairs, err := client.ZRevRangeWithScoresByFloat("key", 0, -1) assert.Nil(t, err) - assert.EqualValues(t, []PairFloat{ + assert.EqualValues(t, []FloatPair{ { Key: "value2", Score: 10.346, @@ -1034,7 +1034,7 @@ func TestRedis_SortedSetByFloat64(t *testing.T) { pairs, err = client.ZrangeWithScoresByFloat("key", 0, -1) assert.Nil(t, err) - assert.EqualValues(t, []PairFloat{ + assert.EqualValues(t, []FloatPair{ { Key: "value1", Score: 10.345, @@ -1046,9 +1046,9 @@ func TestRedis_SortedSetByFloat64(t *testing.T) { }, pairs) _, err = New(client.Addr, badType()).ZrangebyscoreWithScoresByFloat("key", 0, 20) assert.NotNil(t, err) - pairs, err = client.ZrangebyscoreWithScoresByFloat("key", 0,20) + pairs, err = client.ZrangebyscoreWithScoresByFloat("key", 0, 20) assert.Nil(t, err) - assert.EqualValues(t, []PairFloat{ + assert.EqualValues(t, []FloatPair{ { Key: "value1", Score: 10.345, @@ -1063,7 +1063,7 @@ func TestRedis_SortedSetByFloat64(t *testing.T) { assert.NotNil(t, err) pairs, err = client.ZrangebyscoreWithScoresByFloatAndLimit("key", 10.1, 12.2, 1, 1) assert.Nil(t, err) - assert.EqualValues(t, []PairFloat{ + assert.EqualValues(t, []FloatPair{ { Key: "value2", Score: 10.346, @@ -1073,7 +1073,7 @@ func TestRedis_SortedSetByFloat64(t *testing.T) { assert.NotNil(t, err) pairs, err = client.ZrevrangebyscoreWithScoresByFloat("key", 10, 12) assert.Nil(t, err) - assert.EqualValues(t, []PairFloat{ + assert.EqualValues(t, []FloatPair{ { Key: "value2", Score: 10.346, @@ -1088,7 +1088,7 @@ func TestRedis_SortedSetByFloat64(t *testing.T) { assert.NotNil(t, err) pairs, err = client.ZrevrangebyscoreWithScoresByFloatAndLimit("key", 10, 12, 1, 1) assert.Nil(t, err) - assert.EqualValues(t, []PairFloat{ + assert.EqualValues(t, []FloatPair{ { Key: "value1", Score: 10.345, @@ -1101,16 +1101,16 @@ func TestRedis_IncrbyFloat(t *testing.T) { runOnRedis(t, func(client *Redis) { incrVal, err := client.IncrbyFloat("key", 0.002) assert.Nil(t, err) - assert.Equal(t, 0.002,incrVal) + assert.Equal(t, 0.002, incrVal) incrVal2, err := client.IncrbyFloat("key", -0.001) assert.Nil(t, err) - assert.Equal(t, 0.001,incrVal2) - hincrVal ,err := client.HincrbyFloat("hkey","i",0.002) + assert.Equal(t, 0.001, incrVal2) + hincrVal, err := client.HincrbyFloat("hkey", "i", 0.002) assert.Nil(t, err) - assert.Equal(t, 0.002,hincrVal) - hincrVal2 ,err := client.HincrbyFloat("hkey","i",-0.001) + assert.Equal(t, 0.002, hincrVal) + hincrVal2, err := client.HincrbyFloat("hkey", "i", -0.001) assert.Nil(t, err) - assert.Equal(t, 0.001,hincrVal2) + assert.Equal(t, 0.001, hincrVal2) }) } func TestRedis_Pipelined(t *testing.T) {