zeromicro
/
go-zero
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

chore: refactor (#2785)

Browse Source 
* chore: refactor

* chore: refactor
master
Kevin Wan 2 years ago committed by GitHub
parent 00ff50c2cc
commit b2571883ca
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
2 changed files with 71 additions and 55 deletions
Show Stats Download Patch File Download Diff File

100
core/stores/redis/redis.go
Unescape Escape View File

@ -42,10 +42,12 @@ type (
Score int64 Score int64
} }
PairFloat struct { // A FloatPair is a key/pair for float set used in redis zet.
FloatPair struct {
Key string Key string
Score float64 Score float64
} }
// Redis defines a redis node/cluster. It is thread-safe. // Redis defines a redis node/cluster. It is thread-safe.
Redis struct { Redis struct {
Addr string Addr string
@ -1002,6 +1004,7 @@ func (s *Redis) IncrCtx(ctx context.Context, key string) (val int64, err error)
return return
} }
// Incrby is the implementation of redis incrby command. // Incrby is the implementation of redis incrby command.
func (s *Redis) Incrby(key string, increment int64) (int64, error) { func (s *Redis) Incrby(key string, increment int64) (int64, error) {
return s.IncrbyCtx(context.Background(), key, increment) return s.IncrbyCtx(context.Background(), key, increment)
@ -1021,6 +1024,7 @@ func (s *Redis) IncrbyCtx(ctx context.Context, key string, increment int64) (val
return return
} }
// Incrby is the implementation of redis incrby command. // Incrby is the implementation of redis incrby command.
func (s *Redis) IncrbyFloat(key string, increment float64) (float64, error) { func (s *Redis) IncrbyFloat(key string, increment float64) (float64, error) {
return s.IncrbyFloatCtx(context.Background(), key, increment) return s.IncrbyFloatCtx(context.Background(), key, increment)
@ -1040,6 +1044,7 @@ func (s *Redis) IncrbyFloatCtx(ctx context.Context, key string, increment float6
return return
} }
// Keys is the implementation of redis keys command. // Keys is the implementation of redis keys command.
func (s *Redis) Keys(pattern string) ([]string, error) { func (s *Redis) Keys(pattern string) ([]string, error) {
return s.KeysCtx(context.Background(), pattern) 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. // 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) return s.ZrangeWithScoresByFloatCtx(context.Background(), key, start, stop)
} }
// ZrangeWithScoresByFloatCtx is the implementation of redis zrange command with scores by float64. // ZrangeWithScoresByFloatCtx is the implementation of redis zrange command with scores by float64.
func (s *Redis) ZrangeWithScoresByFloatCtx(ctx context.Context, key string, start, stop int64) ( 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 { err = s.brk.DoWithAcceptable(func() error {
conn, err := getRedis(s) conn, err := getRedis(s)
if err != nil { if err != nil {
@ -2265,7 +2270,7 @@ func (s *Redis) ZrangeWithScoresByFloatCtx(ctx context.Context, key string, star
return err return err
} }
val = toPairsByFloat(v) val = toFloatPairs(v)
return nil return nil
}, acceptable) }, 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. // 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) return s.ZRevRangeWithScoresByFloatCtx(context.Background(), key, start, stop)
} }
// ZRevRangeWithScoresByFloatCtx is the implementation of redis zrevrange command with scores by float. // ZRevRangeWithScoresByFloatCtx is the implementation of redis zrevrange command with scores by float.
func (s *Redis) ZRevRangeWithScoresByFloatCtx(ctx context.Context, key string, start, stop int64) ( 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 { err = s.brk.DoWithAcceptable(func() error {
conn, err := getRedis(s) conn, err := getRedis(s)
if err != nil { if err != nil {
@ -2317,7 +2322,7 @@ func (s *Redis) ZRevRangeWithScoresByFloatCtx(ctx context.Context, key string, s
return err return err
} }
val = toPairsByFloat(v) val = toFloatPairs(v)
return nil return nil
}, acceptable) }, 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. // 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) return s.ZrangebyscoreWithScoresByFloatCtx(context.Background(), key, start, stop)
} }
// ZrangebyscoreWithScoresByFloatCtx is the implementation of redis zrangebyscore command with scores by float. // ZrangebyscoreWithScoresByFloatCtx is the implementation of redis zrangebyscore command with scores by float.
func (s *Redis) ZrangebyscoreWithScoresByFloatCtx(ctx context.Context, key string, start, stop float64) ( 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 { err = s.brk.DoWithAcceptable(func() error {
conn, err := getRedis(s) conn, err := getRedis(s)
if err != nil { if err != nil {
@ -2368,14 +2373,14 @@ func (s *Redis) ZrangebyscoreWithScoresByFloatCtx(ctx context.Context, key strin
} }
v, err := conn.ZRangeByScoreWithScores(ctx, key, &red.ZRangeBy{ v, err := conn.ZRangeByScoreWithScores(ctx, key, &red.ZRangeBy{
Min: fmt.Sprintf("%v", start), Min: strconv.FormatFloat(start, 'f', -1, 64),
Max: fmt.Sprintf("%v", stop), Max: strconv.FormatFloat(stop, 'f', -1, 64),
}).Result() }).Result()
if err != nil { if err != nil {
return err return err
} }
val = toPairsByFloat(v) val = toFloatPairs(v)
return nil return nil
}, acceptable) }, acceptable)
@ -2423,14 +2428,15 @@ func (s *Redis) ZrangebyscoreWithScoresAndLimitCtx(ctx context.Context, key stri
// ZrangebyscoreWithScoresByFloatAndLimit is the implementation of redis zrangebyscore command // ZrangebyscoreWithScoresByFloatAndLimit is the implementation of redis zrangebyscore command
// with scores by float and limit. // with scores by float and limit.
func (s *Redis) ZrangebyscoreWithScoresByFloatAndLimit(key string, start, stop float64, func (s *Redis) ZrangebyscoreWithScoresByFloatAndLimit(key string, start, stop float64,
page, size int) ([]PairFloat, error) { page, size int) ([]FloatPair, error) {
return s.ZrangebyscoreWithScoresByFloatAndLimitCtx(context.Background(), key, start, stop, page, size) return s.ZrangebyscoreWithScoresByFloatAndLimitCtx(context.Background(),
key, start, stop, page, size)
} }
// ZrangebyscoreWithScoresByFloatAndLimitCtx is the implementation of redis zrangebyscore command // ZrangebyscoreWithScoresByFloatAndLimitCtx is the implementation of redis zrangebyscore command
// with scores by float and limit. // with scores by float and limit.
func (s *Redis) ZrangebyscoreWithScoresByFloatAndLimitCtx(ctx context.Context, key string, start, 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 { err = s.brk.DoWithAcceptable(func() error {
if size <= 0 { if size <= 0 {
return nil return nil
@ -2442,8 +2448,8 @@ func (s *Redis) ZrangebyscoreWithScoresByFloatAndLimitCtx(ctx context.Context, k
} }
v, err := conn.ZRangeByScoreWithScores(ctx, key, &red.ZRangeBy{ v, err := conn.ZRangeByScoreWithScores(ctx, key, &red.ZRangeBy{
Min: fmt.Sprintf("%v", start), Min: strconv.FormatFloat(start, 'f', -1, 64),
Max: fmt.Sprintf("%v", stop), Max: strconv.FormatFloat(stop, 'f', -1, 64),
Offset: int64(page * size), Offset: int64(page * size),
Count: int64(size), Count: int64(size),
}).Result() }).Result()
@ -2451,7 +2457,7 @@ func (s *Redis) ZrangebyscoreWithScoresByFloatAndLimitCtx(ctx context.Context, k
return err return err
} }
val = toPairsByFloat(v) val = toFloatPairs(v)
return nil return nil
}, acceptable) }, 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. // 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) return s.ZrevrangebyscoreWithScoresByFloatCtx(context.Background(), key, start, stop)
} }
// ZrevrangebyscoreWithScoresByFloatCtx is the implementation of redis zrevrangebyscore command with scores by float. // ZrevrangebyscoreWithScoresByFloatCtx is the implementation of redis zrevrangebyscore command with scores by float.
func (s *Redis) ZrevrangebyscoreWithScoresByFloatCtx(ctx context.Context, key string, start, stop float64) ( func (s *Redis) ZrevrangebyscoreWithScoresByFloatCtx(ctx context.Context, key string,
val []PairFloat, err error) { start, stop float64) (val []FloatPair, err error) {
err = s.brk.DoWithAcceptable(func() error { err = s.brk.DoWithAcceptable(func() error {
conn, err := getRedis(s) conn, err := getRedis(s)
if err != nil { if err != nil {
@ -2523,14 +2530,14 @@ func (s *Redis) ZrevrangebyscoreWithScoresByFloatCtx(ctx context.Context, key st
} }
v, err := conn.ZRevRangeByScoreWithScores(ctx, key, &red.ZRangeBy{ v, err := conn.ZRevRangeByScoreWithScores(ctx, key, &red.ZRangeBy{
Min: fmt.Sprintf("%v", start), Min: strconv.FormatFloat(start, 'f', -1, 64),
Max: fmt.Sprintf("%v", stop), Max: strconv.FormatFloat(stop, 'f', -1, 64),
}).Result() }).Result()
if err != nil { if err != nil {
return err return err
} }
val = toPairsByFloat(v) val = toFloatPairs(v)
return nil return nil
}, acceptable) }, acceptable)
@ -2541,7 +2548,8 @@ func (s *Redis) ZrevrangebyscoreWithScoresByFloatCtx(ctx context.Context, key st
// with scores and limit. // with scores and limit.
func (s *Redis) ZrevrangebyscoreWithScoresAndLimit(key string, start, stop int64, func (s *Redis) ZrevrangebyscoreWithScoresAndLimit(key string, start, stop int64,
page, size int) ([]Pair, error) { 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 // 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 // ZrevrangebyscoreWithScoresByFloatAndLimit is the implementation of redis zrevrangebyscore command
// with scores by float and limit. // with scores by float and limit.
func (s *Redis) ZrevrangebyscoreWithScoresByFloatAndLimit(key string, start, stop float64, func (s *Redis) ZrevrangebyscoreWithScoresByFloatAndLimit(key string, start, stop float64,
page, size int) ([]PairFloat, error) { page, size int) ([]FloatPair, error) {
return s.ZrevrangebyscoreWithScoresByFloatAndLimitCtx(context.Background(), key, start, stop, page, size) return s.ZrevrangebyscoreWithScoresByFloatAndLimitCtx(context.Background(),
key, start, stop, page, size)
} }
// ZrevrangebyscoreWithScoresByFloatAndLimitCtx is the implementation of redis zrevrangebyscore command // ZrevrangebyscoreWithScoresByFloatAndLimitCtx is the implementation of redis zrevrangebyscore command
// with scores by float and limit. // with scores by float and limit.
func (s *Redis) ZrevrangebyscoreWithScoresByFloatAndLimitCtx(ctx context.Context, key string, 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 { err = s.brk.DoWithAcceptable(func() error {
if size <= 0 { if size <= 0 {
return nil return nil
@ -2597,8 +2606,8 @@ func (s *Redis) ZrevrangebyscoreWithScoresByFloatAndLimitCtx(ctx context.Context
} }
v, err := conn.ZRevRangeByScoreWithScores(ctx, key, &red.ZRangeBy{ v, err := conn.ZRevRangeByScoreWithScores(ctx, key, &red.ZRangeBy{
Min: fmt.Sprintf("%v", start), Min: strconv.FormatFloat(start, 'f', -1, 64),
Max: fmt.Sprintf("%v", stop), Max: strconv.FormatFloat(stop, 'f', -1, 64),
Offset: int64(page * size), Offset: int64(page * size),
Count: int64(size), Count: int64(size),
}).Result() }).Result()
@ -2606,7 +2615,7 @@ func (s *Redis) ZrevrangebyscoreWithScoresByFloatAndLimitCtx(ctx context.Context
return err return err
} }
val = toPairsByFloat(v) val = toFloatPairs(v)
return nil return nil
}, acceptable) }, acceptable)
@ -2713,37 +2722,44 @@ func toPairs(vals []red.Z) []Pair {
} }
return pairs 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 { for i, val := range vals {
switch member := val.Member.(type) { switch member := val.Member.(type) {
case string: case string:
pairs[i] = PairFloat{ pairs[i] = FloatPair{
Key: member, Key: member,
Score: val.Score, Score: val.Score,
} }
default: default:
pairs[i] = PairFloat{ pairs[i] = FloatPair{
Key: mapping.Repr(val.Member), Key: mapping.Repr(val.Member),
Score: val.Score, Score: val.Score,
} }
} }
} }
return pairs return pairs
} }
func toStrings(vals []interface{}) []string { func toStrings(vals []interface{}) []string {
ret := make([]string, len(vals)) ret := make([]string, len(vals))
for i, val := range vals { for i, val := range vals {
if val == nil { if val == nil {
ret[i] = "" ret[i] = ""
} else { continue
switch val := val.(type) { }
case string:
ret[i] = val switch val := val.(type) {
default: case string:
ret[i] = mapping.Repr(val) ret[i] = val
} default:
ret[i] = mapping.Repr(val)
} }
} }
return ret return ret
} }

26
core/stores/redis/redis_test.go
Unescape Escape View File

@ -1021,7 +1021,7 @@ func TestRedis_SortedSetByFloat64(t *testing.T) {
assert.NotNil(t, err) assert.NotNil(t, err)
pairs, err := client.ZRevRangeWithScoresByFloat("key", 0, -1) pairs, err := client.ZRevRangeWithScoresByFloat("key", 0, -1)
assert.Nil(t, err) assert.Nil(t, err)
assert.EqualValues(t, []PairFloat{ assert.EqualValues(t, []FloatPair{
{ {
Key: "value2", Key: "value2",
Score: 10.346, Score: 10.346,
@ -1034,7 +1034,7 @@ func TestRedis_SortedSetByFloat64(t *testing.T) {
pairs, err = client.ZrangeWithScoresByFloat("key", 0, -1) pairs, err = client.ZrangeWithScoresByFloat("key", 0, -1)
assert.Nil(t, err) assert.Nil(t, err)
assert.EqualValues(t, []PairFloat{ assert.EqualValues(t, []FloatPair{
{ {
Key: "value1", Key: "value1",
Score: 10.345, Score: 10.345,
@ -1046,9 +1046,9 @@ func TestRedis_SortedSetByFloat64(t *testing.T) {
}, pairs) }, pairs)
_, err = New(client.Addr, badType()).ZrangebyscoreWithScoresByFloat("key", 0, 20) _, err = New(client.Addr, badType()).ZrangebyscoreWithScoresByFloat("key", 0, 20)
assert.NotNil(t, err) assert.NotNil(t, err)
pairs, err = client.ZrangebyscoreWithScoresByFloat("key", 0,20) pairs, err = client.ZrangebyscoreWithScoresByFloat("key", 0, 20)
assert.Nil(t, err) assert.Nil(t, err)
assert.EqualValues(t, []PairFloat{ assert.EqualValues(t, []FloatPair{
{ {
Key: "value1", Key: "value1",
Score: 10.345, Score: 10.345,
@ -1063,7 +1063,7 @@ func TestRedis_SortedSetByFloat64(t *testing.T) {
assert.NotNil(t, err) assert.NotNil(t, err)
pairs, err = client.ZrangebyscoreWithScoresByFloatAndLimit("key", 10.1, 12.2, 1, 1) pairs, err = client.ZrangebyscoreWithScoresByFloatAndLimit("key", 10.1, 12.2, 1, 1)
assert.Nil(t, err) assert.Nil(t, err)
assert.EqualValues(t, []PairFloat{ assert.EqualValues(t, []FloatPair{
{ {
Key: "value2", Key: "value2",
Score: 10.346, Score: 10.346,
@ -1073,7 +1073,7 @@ func TestRedis_SortedSetByFloat64(t *testing.T) {
assert.NotNil(t, err) assert.NotNil(t, err)
pairs, err = client.ZrevrangebyscoreWithScoresByFloat("key", 10, 12) pairs, err = client.ZrevrangebyscoreWithScoresByFloat("key", 10, 12)
assert.Nil(t, err) assert.Nil(t, err)
assert.EqualValues(t, []PairFloat{ assert.EqualValues(t, []FloatPair{
{ {
Key: "value2", Key: "value2",
Score: 10.346, Score: 10.346,
@ -1088,7 +1088,7 @@ func TestRedis_SortedSetByFloat64(t *testing.T) {
assert.NotNil(t, err) assert.NotNil(t, err)
pairs, err = client.ZrevrangebyscoreWithScoresByFloatAndLimit("key", 10, 12, 1, 1) pairs, err = client.ZrevrangebyscoreWithScoresByFloatAndLimit("key", 10, 12, 1, 1)
assert.Nil(t, err) assert.Nil(t, err)
assert.EqualValues(t, []PairFloat{ assert.EqualValues(t, []FloatPair{
{ {
Key: "value1", Key: "value1",
Score: 10.345, Score: 10.345,
@ -1101,16 +1101,16 @@ func TestRedis_IncrbyFloat(t *testing.T) {
runOnRedis(t, func(client *Redis) { runOnRedis(t, func(client *Redis) {
incrVal, err := client.IncrbyFloat("key", 0.002) incrVal, err := client.IncrbyFloat("key", 0.002)
assert.Nil(t, err) assert.Nil(t, err)
assert.Equal(t, 0.002,incrVal) assert.Equal(t, 0.002, incrVal)
incrVal2, err := client.IncrbyFloat("key", -0.001) incrVal2, err := client.IncrbyFloat("key", -0.001)
assert.Nil(t, err) assert.Nil(t, err)
assert.Equal(t, 0.001,incrVal2) assert.Equal(t, 0.001, incrVal2)
hincrVal ,err := client.HincrbyFloat("hkey","i",0.002) hincrVal, err := client.HincrbyFloat("hkey", "i", 0.002)
assert.Nil(t, err) assert.Nil(t, err)
assert.Equal(t, 0.002,hincrVal) assert.Equal(t, 0.002, hincrVal)
hincrVal2 ,err := client.HincrbyFloat("hkey","i",-0.001) hincrVal2, err := client.HincrbyFloat("hkey", "i", -0.001)
assert.Nil(t, err) assert.Nil(t, err)
assert.Equal(t, 0.001,hincrVal2) assert.Equal(t, 0.001, hincrVal2)
}) })
} }
func TestRedis_Pipelined(t *testing.T) { func TestRedis_Pipelined(t *testing.T) {

Write Preview
Loading…
Cancel
Save