Skip to content

Commit 6045d2e

Browse files
yikuaibroyikuaibro
authored
Add support for BZMPOP (#2456)
* Add support for BZMPOP * Add BZMPOP command comment
1 parent 621c02c commit 6045d2e

File tree

2 files changed

+163
-17
lines changed

2 files changed

+163
-17
lines changed

‎commands.go‎

Lines changed: 21 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -299,6 +299,7 @@ type Cmdable interface {
299299

300300
BZPopMax(ctx context.Context, timeout time.Duration, keys ...string) *ZWithKeyCmd
301301
BZPopMin(ctx context.Context, timeout time.Duration, keys ...string) *ZWithKeyCmd
302+
BZMPop(ctx context.Context, timeout time.Duration, order string, count int64, keys ...string) *ZSliceWithKeyCmd
302303

303304
ZAdd(ctx context.Context, key string, members ...Z) *IntCmd
304305
ZAddNX(ctx context.Context, key string, members ...Z) *IntCmd
@@ -2328,6 +2329,26 @@ func (c cmdable) BZPopMin(ctx context.Context, timeout time.Duration, keys ...st
23282329
return cmd
23292330
}
23302331

2332+
// BZMPop is the blocking variant of ZMPOP.
2333+
// When any of the sorted sets contains elements, this command behaves exactly like ZMPOP.
2334+
// When all sorted sets are empty, Redis will block the connection until another client adds members to one of the keys or until the timeout elapses.
2335+
// A timeout of zero can be used to block indefinitely.
2336+
// example: client.BZMPop(ctx, 0,"max", 1, "set")
2337+
func (c cmdable) BZMPop(ctx context.Context, timeout time.Duration, order string, count int64, keys ...string) *ZSliceWithKeyCmd {
2338+
args := make([]interface{}, 3+len(keys), 6+len(keys))
2339+
args[0] = "bzmpop"
2340+
args[1] = formatSec(ctx, timeout)
2341+
args[2] = len(keys)
2342+
for i, key := range keys {
2343+
args[3+i] = key
2344+
}
2345+
args = append(args, strings.ToLower(order), "count", count)
2346+
cmd := NewZSliceWithKeyCmd(ctx, args...)
2347+
cmd.setReadTimeout(timeout)
2348+
_ = c(ctx, cmd)
2349+
return cmd
2350+
}
2351+
23312352
// ZAddArgs WARN: The GT, LT and NX options are mutually exclusive.
23322353
type ZAddArgs struct {
23332354
NX bool

‎commands_test.go‎

Lines changed: 142 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -3772,7 +3772,7 @@ var _ = Describe("Commands", func() {
37723772
Expect(err).NotTo(HaveOccurred())
37733773
Expect(key).To(Equal("zset"))
37743774
Expect(elems).To(Equal([]redis.Z{{
3775-
Score: 1,
3775+
Score: 1,
37763776
Member: "one",
37773777
}}))
37783778

@@ -3790,45 +3790,170 @@ var _ = Describe("Commands", func() {
37903790
Expect(err).NotTo(HaveOccurred())
37913791
Expect(key).To(Equal("myzset"))
37923792
Expect(elems).To(Equal([]redis.Z{{
3793-
Score:1,
3794-
Member:"one",
3793+
Score: 1,
3794+
Member: "one",
37953795
}}))
37963796

37973797
key, elems, err = client.ZMPop(ctx, "max", 10, "myzset").Result()
37983798
Expect(err).NotTo(HaveOccurred())
37993799
Expect(key).To(Equal("myzset"))
38003800
Expect(elems).To(Equal([]redis.Z{{
3801-
Score:3,
3802-
Member:"three",
3803-
},{
3804-
Score: 2,
3801+
Score: 3,
3802+
Member: "three",
3803+
}, {
3804+
Score: 2,
38053805
Member: "two",
38063806
}}))
38073807

3808-
38093808
err = client.ZAdd(ctx, "myzset2", redis.Z{Score: 4, Member: "four"}).Err()
38103809
Expect(err).NotTo(HaveOccurred())
38113810
err = client.ZAdd(ctx, "myzset2", redis.Z{Score: 5, Member: "five"}).Err()
38123811
Expect(err).NotTo(HaveOccurred())
38133812
err = client.ZAdd(ctx, "myzset2", redis.Z{Score: 6, Member: "six"}).Err()
38143813
Expect(err).NotTo(HaveOccurred())
38153814

3816-
key, elems, err = client.ZMPop(ctx, "min", 10, "myzset","myzset2").Result()
3815+
key, elems, err = client.ZMPop(ctx, "min", 10, "myzset", "myzset2").Result()
38173816
Expect(err).NotTo(HaveOccurred())
38183817
Expect(key).To(Equal("myzset2"))
38193818
Expect(elems).To(Equal([]redis.Z{{
3820-
Score:4,
3821-
Member:"four",
3822-
},{
3823-
Score: 5,
3819+
Score: 4,
3820+
Member: "four",
3821+
}, {
3822+
Score: 5,
38243823
Member: "five",
3825-
},{
3826-
Score:6,
3824+
}, {
3825+
Score: 6,
38273826
Member: "six",
38283827
}}))
38293828

3830-
3831-
3829+
})
3830+
3831+
It("should BZMPop", func() {
3832+
3833+
err := client.ZAdd(ctx, "zset", redis.Z{Score: 1, Member: "one"}).Err()
3834+
Expect(err).NotTo(HaveOccurred())
3835+
err = client.ZAdd(ctx, "zset", redis.Z{Score: 2, Member: "two"}).Err()
3836+
Expect(err).NotTo(HaveOccurred())
3837+
err = client.ZAdd(ctx, "zset", redis.Z{Score: 3, Member: "three"}).Err()
3838+
Expect(err).NotTo(HaveOccurred())
3839+
3840+
err = client.ZAdd(ctx, "zset2", redis.Z{Score: 1, Member: "one"}).Err()
3841+
Expect(err).NotTo(HaveOccurred())
3842+
err = client.ZAdd(ctx, "zset2", redis.Z{Score: 2, Member: "two"}).Err()
3843+
Expect(err).NotTo(HaveOccurred())
3844+
err = client.ZAdd(ctx, "zset2", redis.Z{Score: 3, Member: "three"}).Err()
3845+
Expect(err).NotTo(HaveOccurred())
3846+
3847+
key, elems, err := client.BZMPop(ctx, 0, "min", 1, "zset").Result()
3848+
Expect(err).NotTo(HaveOccurred())
3849+
Expect(key).To(Equal("zset"))
3850+
Expect(elems).To(Equal([]redis.Z{{
3851+
Score: 1,
3852+
Member: "one",
3853+
}}))
3854+
key, elems, err = client.BZMPop(ctx, 0, "max", 1, "zset").Result()
3855+
Expect(err).NotTo(HaveOccurred())
3856+
Expect(key).To(Equal("zset"))
3857+
Expect(elems).To(Equal([]redis.Z{{
3858+
Score: 3,
3859+
Member: "three",
3860+
}}))
3861+
key, elems, err = client.BZMPop(ctx, 0, "min", 10, "zset").Result()
3862+
Expect(err).NotTo(HaveOccurred())
3863+
Expect(key).To(Equal("zset"))
3864+
Expect(elems).To(Equal([]redis.Z{{
3865+
Score: 2,
3866+
Member: "two",
3867+
}}))
3868+
3869+
key, elems, err = client.BZMPop(ctx, 0, "max", 10, "zset2").Result()
3870+
Expect(err).NotTo(HaveOccurred())
3871+
Expect(key).To(Equal("zset2"))
3872+
Expect(elems).To(Equal([]redis.Z{{
3873+
Score: 3,
3874+
Member: "three",
3875+
}, {
3876+
Score: 2,
3877+
Member: "two",
3878+
}, {
3879+
Score: 1,
3880+
Member: "one",
3881+
}}))
3882+
3883+
err = client.ZAdd(ctx, "myzset", redis.Z{Score: 1, Member: "one"}).Err()
3884+
Expect(err).NotTo(HaveOccurred())
3885+
key, elems, err = client.BZMPop(ctx, 0, "min", 10, "myzset").Result()
3886+
Expect(err).NotTo(HaveOccurred())
3887+
Expect(key).To(Equal("myzset"))
3888+
Expect(elems).To(Equal([]redis.Z{{
3889+
Score: 1,
3890+
Member: "one",
3891+
}}))
3892+
3893+
err = client.ZAdd(ctx, "myzset2", redis.Z{Score: 4, Member: "four"}).Err()
3894+
Expect(err).NotTo(HaveOccurred())
3895+
err = client.ZAdd(ctx, "myzset2", redis.Z{Score: 5, Member: "five"}).Err()
3896+
Expect(err).NotTo(HaveOccurred())
3897+
3898+
key, elems, err = client.BZMPop(ctx, 0, "min", 10, "myzset", "myzset2").Result()
3899+
Expect(err).NotTo(HaveOccurred())
3900+
Expect(key).To(Equal("myzset2"))
3901+
Expect(elems).To(Equal([]redis.Z{{
3902+
Score: 4,
3903+
Member: "four",
3904+
}, {
3905+
Score: 5,
3906+
Member: "five",
3907+
}}))
3908+
})
3909+
3910+
It("should BZMPopBlocks", func() {
3911+
started := make(chan bool)
3912+
done := make(chan bool)
3913+
go func() {
3914+
defer GinkgoRecover()
3915+
3916+
started <- true
3917+
key, elems, err := client.BZMPop(ctx, 0, "min", 1, "list_list").Result()
3918+
Expect(err).NotTo(HaveOccurred())
3919+
Expect(key).To(Equal("list_list"))
3920+
Expect(elems).To(Equal([]redis.Z{{
3921+
Score: 1,
3922+
Member: "one",
3923+
}}))
3924+
done <- true
3925+
}()
3926+
<-started
3927+
3928+
select {
3929+
case <-done:
3930+
Fail("BZMPop is not blocked")
3931+
case <-time.After(time.Second):
3932+
//ok
3933+
}
3934+
3935+
err := client.ZAdd(ctx, "list_list", redis.Z{Score: 1, Member: "one"}).Err()
3936+
Expect(err).NotTo(HaveOccurred())
3937+
3938+
select {
3939+
case <-done:
3940+
//ok
3941+
case <-time.After(time.Second):
3942+
Fail("BZMPop is still blocked")
3943+
}
3944+
})
3945+
3946+
It("should BZMPop timeout", func() {
3947+
_, val, err := client.BZMPop(ctx, time.Second, "min", 1, "list1").Result()
3948+
Expect(err).To(Equal(redis.Nil))
3949+
Expect(val).To(BeNil())
3950+
3951+
Expect(client.Ping(ctx).Err()).NotTo(HaveOccurred())
3952+
3953+
stats := client.PoolStats()
3954+
Expect(stats.Hits).To(Equal(uint32(2)))
3955+
Expect(stats.Misses).To(Equal(uint32(1)))
3956+
Expect(stats.Timeouts).To(Equal(uint32(0)))
38323957
})
38333958

38343959
It("should ZMScore", func() {

0 commit comments

Comments
 (0)