1start_server {tags {"zset"}} { 2 proc create_zset {key items} { 3 r del $key 4 foreach {score entry} $items { 5 r zadd $key $score $entry 6 } 7 } 8 9 proc basics {encoding} { 10 if {$encoding == "ziplist"} { 11 r config set zset-max-ziplist-entries 128 12 r config set zset-max-ziplist-value 64 13 } elseif {$encoding == "skiplist"} { 14 r config set zset-max-ziplist-entries 0 15 r config set zset-max-ziplist-value 0 16 } else { 17 puts "Unknown sorted set encoding" 18 exit 19 } 20 21 test "Check encoding - $encoding" { 22 r del ztmp 23 r zadd ztmp 10 x 24 assert_encoding $encoding ztmp 25 } 26 27 test "ZSET basic ZADD and score update - $encoding" { 28 r del ztmp 29 r zadd ztmp 10 x 30 r zadd ztmp 20 y 31 r zadd ztmp 30 z 32 assert_equal {x y z} [r zrange ztmp 0 -1] 33 34 r zadd ztmp 1 y 35 assert_equal {y x z} [r zrange ztmp 0 -1] 36 } 37 38 test "ZSET element can't be set to NaN with ZADD - $encoding" { 39 assert_error "*not*float*" {r zadd myzset nan abc} 40 } 41 42 test "ZSET element can't be set to NaN with ZINCRBY" { 43 assert_error "*not*float*" {r zadd myzset nan abc} 44 } 45 46 test "ZINCRBY calls leading to NaN result in error" { 47 r zincrby myzset +inf abc 48 assert_error "*NaN*" {r zincrby myzset -inf abc} 49 } 50 51 test {ZADD - Variadic version base case} { 52 r del myzset 53 list [r zadd myzset 10 a 20 b 30 c] [r zrange myzset 0 -1 withscores] 54 } {3 {a 10 b 20 c 30}} 55 56 test {ZADD - Return value is the number of actually added items} { 57 list [r zadd myzset 5 x 20 b 30 c] [r zrange myzset 0 -1 withscores] 58 } {1 {x 5 a 10 b 20 c 30}} 59 60 test {ZADD - Variadic version does not add nothing on single parsing err} { 61 r del myzset 62 catch {r zadd myzset 10 a 20 b 30.badscore c} e 63 assert_match {*ERR*not*float*} $e 64 r exists myzset 65 } {0} 66 67 test {ZADD - Variadic version will raise error on missing arg} { 68 r del myzset 69 catch {r zadd myzset 10 a 20 b 30 c 40} e 70 assert_match {*ERR*syntax*} $e 71 } 72 73 test {ZINCRBY does not work variadic even if shares ZADD implementation} { 74 r del myzset 75 catch {r zincrby myzset 10 a 20 b 30 c} e 76 assert_match {*ERR*wrong*number*arg*} $e 77 } 78 79 test "ZCARD basics - $encoding" { 80 assert_equal 3 [r zcard ztmp] 81 assert_equal 0 [r zcard zdoesntexist] 82 } 83 84 test "ZREM removes key after last element is removed" { 85 r del ztmp 86 r zadd ztmp 10 x 87 r zadd ztmp 20 y 88 89 assert_equal 1 [r exists ztmp] 90 assert_equal 0 [r zrem ztmp z] 91 assert_equal 1 [r zrem ztmp y] 92 assert_equal 1 [r zrem ztmp x] 93 assert_equal 0 [r exists ztmp] 94 } 95 96 test "ZREM variadic version" { 97 r del ztmp 98 r zadd ztmp 10 a 20 b 30 c 99 assert_equal 2 [r zrem ztmp x y a b k] 100 assert_equal 0 [r zrem ztmp foo bar] 101 assert_equal 1 [r zrem ztmp c] 102 r exists ztmp 103 } {0} 104 105 test "ZREM variadic version -- remove elements after key deletion" { 106 r del ztmp 107 r zadd ztmp 10 a 20 b 30 c 108 r zrem ztmp a b c d e f g 109 } {3} 110 111 test "ZRANGE basics - $encoding" { 112 r del ztmp 113 r zadd ztmp 1 a 114 r zadd ztmp 2 b 115 r zadd ztmp 3 c 116 r zadd ztmp 4 d 117 118 assert_equal {a b c d} [r zrange ztmp 0 -1] 119 assert_equal {a b c} [r zrange ztmp 0 -2] 120 assert_equal {b c d} [r zrange ztmp 1 -1] 121 assert_equal {b c} [r zrange ztmp 1 -2] 122 assert_equal {c d} [r zrange ztmp -2 -1] 123 assert_equal {c} [r zrange ztmp -2 -2] 124 125 # out of range start index 126 assert_equal {a b c} [r zrange ztmp -5 2] 127 assert_equal {a b} [r zrange ztmp -5 1] 128 assert_equal {} [r zrange ztmp 5 -1] 129 assert_equal {} [r zrange ztmp 5 -2] 130 131 # out of range end index 132 assert_equal {a b c d} [r zrange ztmp 0 5] 133 assert_equal {b c d} [r zrange ztmp 1 5] 134 assert_equal {} [r zrange ztmp 0 -5] 135 assert_equal {} [r zrange ztmp 1 -5] 136 137 # withscores 138 assert_equal {a 1 b 2 c 3 d 4} [r zrange ztmp 0 -1 withscores] 139 } 140 141 test "ZREVRANGE basics - $encoding" { 142 r del ztmp 143 r zadd ztmp 1 a 144 r zadd ztmp 2 b 145 r zadd ztmp 3 c 146 r zadd ztmp 4 d 147 148 assert_equal {d c b a} [r zrevrange ztmp 0 -1] 149 assert_equal {d c b} [r zrevrange ztmp 0 -2] 150 assert_equal {c b a} [r zrevrange ztmp 1 -1] 151 assert_equal {c b} [r zrevrange ztmp 1 -2] 152 assert_equal {b a} [r zrevrange ztmp -2 -1] 153 assert_equal {b} [r zrevrange ztmp -2 -2] 154 155 # out of range start index 156 assert_equal {d c b} [r zrevrange ztmp -5 2] 157 assert_equal {d c} [r zrevrange ztmp -5 1] 158 assert_equal {} [r zrevrange ztmp 5 -1] 159 assert_equal {} [r zrevrange ztmp 5 -2] 160 161 # out of range end index 162 assert_equal {d c b a} [r zrevrange ztmp 0 5] 163 assert_equal {c b a} [r zrevrange ztmp 1 5] 164 assert_equal {} [r zrevrange ztmp 0 -5] 165 assert_equal {} [r zrevrange ztmp 1 -5] 166 167 # withscores 168 assert_equal {d 4 c 3 b 2 a 1} [r zrevrange ztmp 0 -1 withscores] 169 } 170 171 test "ZRANK/ZREVRANK basics - $encoding" { 172 r del zranktmp 173 r zadd zranktmp 10 x 174 r zadd zranktmp 20 y 175 r zadd zranktmp 30 z 176 assert_equal 0 [r zrank zranktmp x] 177 assert_equal 1 [r zrank zranktmp y] 178 assert_equal 2 [r zrank zranktmp z] 179 assert_equal "" [r zrank zranktmp foo] 180 assert_equal 2 [r zrevrank zranktmp x] 181 assert_equal 1 [r zrevrank zranktmp y] 182 assert_equal 0 [r zrevrank zranktmp z] 183 assert_equal "" [r zrevrank zranktmp foo] 184 } 185 186 test "ZRANK - after deletion - $encoding" { 187 r zrem zranktmp y 188 assert_equal 0 [r zrank zranktmp x] 189 assert_equal 1 [r zrank zranktmp z] 190 } 191 192 test "ZINCRBY - can create a new sorted set - $encoding" { 193 r del zset 194 r zincrby zset 1 foo 195 assert_equal {foo} [r zrange zset 0 -1] 196 assert_equal 1 [r zscore zset foo] 197 } 198 199 test "ZINCRBY - increment and decrement - $encoding" { 200 r zincrby zset 2 foo 201 r zincrby zset 1 bar 202 assert_equal {bar foo} [r zrange zset 0 -1] 203 204 r zincrby zset 10 bar 205 r zincrby zset -5 foo 206 r zincrby zset -5 bar 207 assert_equal {foo bar} [r zrange zset 0 -1] 208 209 assert_equal -2 [r zscore zset foo] 210 assert_equal 6 [r zscore zset bar] 211 } 212 213 proc create_default_zset {} { 214 create_zset zset {-inf a 1 b 2 c 3 d 4 e 5 f +inf g} 215 } 216 217 test "ZRANGEBYSCORE/ZREVRANGEBYSCORE/ZCOUNT basics" { 218 create_default_zset 219 220 # inclusive range 221 assert_equal {a b c} [r zrangebyscore zset -inf 2] 222 assert_equal {b c d} [r zrangebyscore zset 0 3] 223 assert_equal {d e f} [r zrangebyscore zset 3 6] 224 assert_equal {e f g} [r zrangebyscore zset 4 +inf] 225 assert_equal {c b a} [r zrevrangebyscore zset 2 -inf] 226 assert_equal {d c b} [r zrevrangebyscore zset 3 0] 227 assert_equal {f e d} [r zrevrangebyscore zset 6 3] 228 assert_equal {g f e} [r zrevrangebyscore zset +inf 4] 229 assert_equal 3 [r zcount zset 0 3] 230 231 # exclusive range 232 assert_equal {b} [r zrangebyscore zset (-inf (2] 233 assert_equal {b c} [r zrangebyscore zset (0 (3] 234 assert_equal {e f} [r zrangebyscore zset (3 (6] 235 assert_equal {f} [r zrangebyscore zset (4 (+inf] 236 assert_equal {b} [r zrevrangebyscore zset (2 (-inf] 237 assert_equal {c b} [r zrevrangebyscore zset (3 (0] 238 assert_equal {f e} [r zrevrangebyscore zset (6 (3] 239 assert_equal {f} [r zrevrangebyscore zset (+inf (4] 240 assert_equal 2 [r zcount zset (0 (3] 241 242 # test empty ranges 243 r zrem zset a 244 r zrem zset g 245 246 # inclusive 247 assert_equal {} [r zrangebyscore zset 4 2] 248 assert_equal {} [r zrangebyscore zset 6 +inf] 249 assert_equal {} [r zrangebyscore zset -inf -6] 250 assert_equal {} [r zrevrangebyscore zset +inf 6] 251 assert_equal {} [r zrevrangebyscore zset -6 -inf] 252 253 # exclusive 254 assert_equal {} [r zrangebyscore zset (4 (2] 255 assert_equal {} [r zrangebyscore zset 2 (2] 256 assert_equal {} [r zrangebyscore zset (2 2] 257 assert_equal {} [r zrangebyscore zset (6 (+inf] 258 assert_equal {} [r zrangebyscore zset (-inf (-6] 259 assert_equal {} [r zrevrangebyscore zset (+inf (6] 260 assert_equal {} [r zrevrangebyscore zset (-6 (-inf] 261 262 # empty inner range 263 assert_equal {} [r zrangebyscore zset 2.4 2.6] 264 assert_equal {} [r zrangebyscore zset (2.4 2.6] 265 assert_equal {} [r zrangebyscore zset 2.4 (2.6] 266 assert_equal {} [r zrangebyscore zset (2.4 (2.6] 267 } 268 269 test "ZRANGEBYSCORE with WITHSCORES" { 270 create_default_zset 271 assert_equal {b 1 c 2 d 3} [r zrangebyscore zset 0 3 withscores] 272 assert_equal {d 3 c 2 b 1} [r zrevrangebyscore zset 3 0 withscores] 273 } 274 275 test "ZRANGEBYSCORE with LIMIT" { 276 create_default_zset 277 assert_equal {b c} [r zrangebyscore zset 0 10 LIMIT 0 2] 278 assert_equal {d e f} [r zrangebyscore zset 0 10 LIMIT 2 3] 279 assert_equal {d e f} [r zrangebyscore zset 0 10 LIMIT 2 10] 280 assert_equal {} [r zrangebyscore zset 0 10 LIMIT 20 10] 281 assert_equal {f e} [r zrevrangebyscore zset 10 0 LIMIT 0 2] 282 assert_equal {d c b} [r zrevrangebyscore zset 10 0 LIMIT 2 3] 283 assert_equal {d c b} [r zrevrangebyscore zset 10 0 LIMIT 2 10] 284 assert_equal {} [r zrevrangebyscore zset 10 0 LIMIT 20 10] 285 } 286 287 test "ZRANGEBYSCORE with LIMIT and WITHSCORES" { 288 create_default_zset 289 assert_equal {e 4 f 5} [r zrangebyscore zset 2 5 LIMIT 2 3 WITHSCORES] 290 assert_equal {d 3 c 2} [r zrevrangebyscore zset 5 2 LIMIT 2 3 WITHSCORES] 291 } 292 293 test "ZRANGEBYSCORE with non-value min or max" { 294 assert_error "*not*float*" {r zrangebyscore fooz str 1} 295 assert_error "*not*float*" {r zrangebyscore fooz 1 str} 296 assert_error "*not*float*" {r zrangebyscore fooz 1 NaN} 297 } 298 299 proc create_default_lex_zset {} { 300 create_zset zset {0 alpha 0 bar 0 cool 0 down 301 0 elephant 0 foo 0 great 0 hill 302 0 omega} 303 } 304 305 test "ZRANGEBYLEX/ZREVRANGEBYLEX/ZCOUNT basics" { 306 create_default_lex_zset 307 308 # inclusive range 309 assert_equal {alpha bar cool} [r zrangebylex zset - \[cool] 310 assert_equal {bar cool down} [r zrangebylex zset \[bar \[down] 311 assert_equal {great hill omega} [r zrangebylex zset \[g +] 312 assert_equal {cool bar alpha} [r zrevrangebylex zset \[cool -] 313 assert_equal {down cool bar} [r zrevrangebylex zset \[down \[bar] 314 assert_equal {omega hill great foo elephant down} [r zrevrangebylex zset + \[d] 315 assert_equal 3 [r zlexcount zset \[ele \[h] 316 317 # exclusive range 318 assert_equal {alpha bar} [r zrangebylex zset - (cool] 319 assert_equal {cool} [r zrangebylex zset (bar (down] 320 assert_equal {hill omega} [r zrangebylex zset (great +] 321 assert_equal {bar alpha} [r zrevrangebylex zset (cool -] 322 assert_equal {cool} [r zrevrangebylex zset (down (bar] 323 assert_equal {omega hill} [r zrevrangebylex zset + (great] 324 assert_equal 2 [r zlexcount zset (ele (great] 325 326 # inclusive and exclusive 327 assert_equal {} [r zrangebylex zset (az (b] 328 assert_equal {} [r zrangebylex zset (z +] 329 assert_equal {} [r zrangebylex zset - \[aaaa] 330 assert_equal {} [r zrevrangebylex zset \[elez \[elex] 331 assert_equal {} [r zrevrangebylex zset (hill (omega] 332 } 333 334 test "ZRANGEBYSLEX with LIMIT" { 335 create_default_lex_zset 336 assert_equal {alpha bar} [r zrangebylex zset - \[cool LIMIT 0 2] 337 assert_equal {bar cool} [r zrangebylex zset - \[cool LIMIT 1 2] 338 assert_equal {} [r zrangebylex zset \[bar \[down LIMIT 0 0] 339 assert_equal {} [r zrangebylex zset \[bar \[down LIMIT 2 0] 340 assert_equal {bar} [r zrangebylex zset \[bar \[down LIMIT 0 1] 341 assert_equal {cool} [r zrangebylex zset \[bar \[down LIMIT 1 1] 342 assert_equal {bar cool down} [r zrangebylex zset \[bar \[down LIMIT 0 100] 343 assert_equal {omega hill great foo elephant} [r zrevrangebylex zset + \[d LIMIT 0 5] 344 assert_equal {omega hill great foo} [r zrevrangebylex zset + \[d LIMIT 0 4] 345 } 346 347 test "ZRANGEBYLEX with invalid lex range specifiers" { 348 assert_error "*not*string*" {r zrangebylex fooz foo bar} 349 assert_error "*not*string*" {r zrangebylex fooz \[foo bar} 350 assert_error "*not*string*" {r zrangebylex fooz foo \[bar} 351 assert_error "*not*string*" {r zrangebylex fooz +x \[bar} 352 assert_error "*not*string*" {r zrangebylex fooz -x \[bar} 353 } 354 355 test "ZREMRANGEBYSCORE basics" { 356 proc remrangebyscore {min max} { 357 create_zset zset {1 a 2 b 3 c 4 d 5 e} 358 assert_equal 1 [r exists zset] 359 r zremrangebyscore zset $min $max 360 } 361 362 # inner range 363 assert_equal 3 [remrangebyscore 2 4] 364 assert_equal {a e} [r zrange zset 0 -1] 365 366 # start underflow 367 assert_equal 1 [remrangebyscore -10 1] 368 assert_equal {b c d e} [r zrange zset 0 -1] 369 370 # end overflow 371 assert_equal 1 [remrangebyscore 5 10] 372 assert_equal {a b c d} [r zrange zset 0 -1] 373 374 # switch min and max 375 assert_equal 0 [remrangebyscore 4 2] 376 assert_equal {a b c d e} [r zrange zset 0 -1] 377 378 # -inf to mid 379 assert_equal 3 [remrangebyscore -inf 3] 380 assert_equal {d e} [r zrange zset 0 -1] 381 382 # mid to +inf 383 assert_equal 3 [remrangebyscore 3 +inf] 384 assert_equal {a b} [r zrange zset 0 -1] 385 386 # -inf to +inf 387 assert_equal 5 [remrangebyscore -inf +inf] 388 assert_equal {} [r zrange zset 0 -1] 389 390 # exclusive min 391 assert_equal 4 [remrangebyscore (1 5] 392 assert_equal {a} [r zrange zset 0 -1] 393 assert_equal 3 [remrangebyscore (2 5] 394 assert_equal {a b} [r zrange zset 0 -1] 395 396 # exclusive max 397 assert_equal 4 [remrangebyscore 1 (5] 398 assert_equal {e} [r zrange zset 0 -1] 399 assert_equal 3 [remrangebyscore 1 (4] 400 assert_equal {d e} [r zrange zset 0 -1] 401 402 # exclusive min and max 403 assert_equal 3 [remrangebyscore (1 (5] 404 assert_equal {a e} [r zrange zset 0 -1] 405 406 # destroy when empty 407 assert_equal 5 [remrangebyscore 1 5] 408 assert_equal 0 [r exists zset] 409 } 410 411 test "ZREMRANGEBYSCORE with non-value min or max" { 412 assert_error "*not*float*" {r zremrangebyscore fooz str 1} 413 assert_error "*not*float*" {r zremrangebyscore fooz 1 str} 414 assert_error "*not*float*" {r zremrangebyscore fooz 1 NaN} 415 } 416 417 test "ZREMRANGEBYRANK basics" { 418 proc remrangebyrank {min max} { 419 create_zset zset {1 a 2 b 3 c 4 d 5 e} 420 assert_equal 1 [r exists zset] 421 r zremrangebyrank zset $min $max 422 } 423 424 # inner range 425 assert_equal 3 [remrangebyrank 1 3] 426 assert_equal {a e} [r zrange zset 0 -1] 427 428 # start underflow 429 assert_equal 1 [remrangebyrank -10 0] 430 assert_equal {b c d e} [r zrange zset 0 -1] 431 432 # start overflow 433 assert_equal 0 [remrangebyrank 10 -1] 434 assert_equal {a b c d e} [r zrange zset 0 -1] 435 436 # end underflow 437 assert_equal 0 [remrangebyrank 0 -10] 438 assert_equal {a b c d e} [r zrange zset 0 -1] 439 440 # end overflow 441 assert_equal 5 [remrangebyrank 0 10] 442 assert_equal {} [r zrange zset 0 -1] 443 444 # destroy when empty 445 assert_equal 5 [remrangebyrank 0 4] 446 assert_equal 0 [r exists zset] 447 } 448 449 test "ZUNIONSTORE against non-existing key doesn't set destination - $encoding" { 450 r del zseta 451 assert_equal 0 [r zunionstore dst_key 1 zseta] 452 assert_equal 0 [r exists dst_key] 453 } 454 455 test "ZUNIONSTORE with empty set - $encoding" { 456 r del zseta zsetb 457 r zadd zseta 1 a 458 r zadd zseta 2 b 459 r zunionstore zsetc 2 zseta zsetb 460 r zrange zsetc 0 -1 withscores 461 } {a 1 b 2} 462 463 test "ZUNIONSTORE basics - $encoding" { 464 r del zseta zsetb zsetc 465 r zadd zseta 1 a 466 r zadd zseta 2 b 467 r zadd zseta 3 c 468 r zadd zsetb 1 b 469 r zadd zsetb 2 c 470 r zadd zsetb 3 d 471 472 assert_equal 4 [r zunionstore zsetc 2 zseta zsetb] 473 assert_equal {a 1 b 3 d 3 c 5} [r zrange zsetc 0 -1 withscores] 474 } 475 476 test "ZUNIONSTORE with weights - $encoding" { 477 assert_equal 4 [r zunionstore zsetc 2 zseta zsetb weights 2 3] 478 assert_equal {a 2 b 7 d 9 c 12} [r zrange zsetc 0 -1 withscores] 479 } 480 481 test "ZUNIONSTORE with a regular set and weights - $encoding" { 482 r del seta 483 r sadd seta a 484 r sadd seta b 485 r sadd seta c 486 487 assert_equal 4 [r zunionstore zsetc 2 seta zsetb weights 2 3] 488 assert_equal {a 2 b 5 c 8 d 9} [r zrange zsetc 0 -1 withscores] 489 } 490 491 test "ZUNIONSTORE with AGGREGATE MIN - $encoding" { 492 assert_equal 4 [r zunionstore zsetc 2 zseta zsetb aggregate min] 493 assert_equal {a 1 b 1 c 2 d 3} [r zrange zsetc 0 -1 withscores] 494 } 495 496 test "ZUNIONSTORE with AGGREGATE MAX - $encoding" { 497 assert_equal 4 [r zunionstore zsetc 2 zseta zsetb aggregate max] 498 assert_equal {a 1 b 2 c 3 d 3} [r zrange zsetc 0 -1 withscores] 499 } 500 501 test "ZINTERSTORE basics - $encoding" { 502 assert_equal 2 [r zinterstore zsetc 2 zseta zsetb] 503 assert_equal {b 3 c 5} [r zrange zsetc 0 -1 withscores] 504 } 505 506 test "ZINTERSTORE with weights - $encoding" { 507 assert_equal 2 [r zinterstore zsetc 2 zseta zsetb weights 2 3] 508 assert_equal {b 7 c 12} [r zrange zsetc 0 -1 withscores] 509 } 510 511 test "ZINTERSTORE with a regular set and weights - $encoding" { 512 r del seta 513 r sadd seta a 514 r sadd seta b 515 r sadd seta c 516 assert_equal 2 [r zinterstore zsetc 2 seta zsetb weights 2 3] 517 assert_equal {b 5 c 8} [r zrange zsetc 0 -1 withscores] 518 } 519 520 test "ZINTERSTORE with AGGREGATE MIN - $encoding" { 521 assert_equal 2 [r zinterstore zsetc 2 zseta zsetb aggregate min] 522 assert_equal {b 1 c 2} [r zrange zsetc 0 -1 withscores] 523 } 524 525 test "ZINTERSTORE with AGGREGATE MAX - $encoding" { 526 assert_equal 2 [r zinterstore zsetc 2 zseta zsetb aggregate max] 527 assert_equal {b 2 c 3} [r zrange zsetc 0 -1 withscores] 528 } 529 530 foreach cmd {ZUNIONSTORE ZINTERSTORE} { 531 test "$cmd with +inf/-inf scores - $encoding" { 532 r del zsetinf1 zsetinf2 533 534 r zadd zsetinf1 +inf key 535 r zadd zsetinf2 +inf key 536 r $cmd zsetinf3 2 zsetinf1 zsetinf2 537 assert_equal inf [r zscore zsetinf3 key] 538 539 r zadd zsetinf1 -inf key 540 r zadd zsetinf2 +inf key 541 r $cmd zsetinf3 2 zsetinf1 zsetinf2 542 assert_equal 0 [r zscore zsetinf3 key] 543 544 r zadd zsetinf1 +inf key 545 r zadd zsetinf2 -inf key 546 r $cmd zsetinf3 2 zsetinf1 zsetinf2 547 assert_equal 0 [r zscore zsetinf3 key] 548 549 r zadd zsetinf1 -inf key 550 r zadd zsetinf2 -inf key 551 r $cmd zsetinf3 2 zsetinf1 zsetinf2 552 assert_equal -inf [r zscore zsetinf3 key] 553 } 554 555 test "$cmd with NaN weights $encoding" { 556 r del zsetinf1 zsetinf2 557 558 r zadd zsetinf1 1.0 key 559 r zadd zsetinf2 1.0 key 560 assert_error "*weight*not*float*" { 561 r $cmd zsetinf3 2 zsetinf1 zsetinf2 weights nan nan 562 } 563 } 564 } 565 } 566 567 basics ziplist 568 basics skiplist 569 570 test {ZINTERSTORE regression with two sets, intset+hashtable} { 571 r del seta setb setc 572 r sadd set1 a 573 r sadd set2 10 574 r zinterstore set3 2 set1 set2 575 } {0} 576 577 test {ZUNIONSTORE regression, should not create NaN in scores} { 578 r zadd z -inf neginf 579 r zunionstore out 1 z weights 0 580 r zrange out 0 -1 withscores 581 } {neginf 0} 582 583 test {ZINTERSTORE #516 regression, mixed sets and ziplist zsets} { 584 r sadd one 100 101 102 103 585 r sadd two 100 200 201 202 586 r zadd three 1 500 1 501 1 502 1 503 1 100 587 r zinterstore to_here 3 one two three WEIGHTS 0 0 1 588 r zrange to_here 0 -1 589 } {100} 590 591 test {ZUNIONSTORE result is sorted} { 592 # Create two sets with common and not common elements, perform 593 # the UNION, check that elements are still sorted. 594 r del one two dest 595 set cmd1 [list r zadd one] 596 set cmd2 [list r zadd two] 597 for {set j 0} {$j < 1000} {incr j} { 598 lappend cmd1 [expr rand()] [randomInt 1000] 599 lappend cmd2 [expr rand()] [randomInt 1000] 600 } 601 {*}$cmd1 602 {*}$cmd2 603 assert {[r zcard one] > 100} 604 assert {[r zcard two] > 100} 605 r zunionstore dest 2 one two 606 set oldscore 0 607 foreach {ele score} [r zrange dest 0 -1 withscores] { 608 assert {$score >= $oldscore} 609 set oldscore $score 610 } 611 } 612 613 proc stressers {encoding} { 614 if {$encoding == "ziplist"} { 615 # Little extra to allow proper fuzzing in the sorting stresser 616 r config set zset-max-ziplist-entries 256 617 r config set zset-max-ziplist-value 64 618 set elements 128 619 } elseif {$encoding == "skiplist"} { 620 r config set zset-max-ziplist-entries 0 621 r config set zset-max-ziplist-value 0 622 if {$::accurate} {set elements 1000} else {set elements 100} 623 } else { 624 puts "Unknown sorted set encoding" 625 exit 626 } 627 628 test "ZSCORE - $encoding" { 629 r del zscoretest 630 set aux {} 631 for {set i 0} {$i < $elements} {incr i} { 632 set score [expr rand()] 633 lappend aux $score 634 r zadd zscoretest $score $i 635 } 636 637 assert_encoding $encoding zscoretest 638 for {set i 0} {$i < $elements} {incr i} { 639 assert_equal [lindex $aux $i] [r zscore zscoretest $i] 640 } 641 } 642 643 test "ZSCORE after a DEBUG RELOAD - $encoding" { 644 r del zscoretest 645 set aux {} 646 for {set i 0} {$i < $elements} {incr i} { 647 set score [expr rand()] 648 lappend aux $score 649 r zadd zscoretest $score $i 650 } 651 652 r debug reload 653 assert_encoding $encoding zscoretest 654 for {set i 0} {$i < $elements} {incr i} { 655 assert_equal [lindex $aux $i] [r zscore zscoretest $i] 656 } 657 } 658 659 test "ZSET sorting stresser - $encoding" { 660 set delta 0 661 for {set test 0} {$test < 2} {incr test} { 662 unset -nocomplain auxarray 663 array set auxarray {} 664 set auxlist {} 665 r del myzset 666 for {set i 0} {$i < $elements} {incr i} { 667 if {$test == 0} { 668 set score [expr rand()] 669 } else { 670 set score [expr int(rand()*10)] 671 } 672 set auxarray($i) $score 673 r zadd myzset $score $i 674 # Random update 675 if {[expr rand()] < .2} { 676 set j [expr int(rand()*1000)] 677 if {$test == 0} { 678 set score [expr rand()] 679 } else { 680 set score [expr int(rand()*10)] 681 } 682 set auxarray($j) $score 683 r zadd myzset $score $j 684 } 685 } 686 foreach {item score} [array get auxarray] { 687 lappend auxlist [list $score $item] 688 } 689 set sorted [lsort -command zlistAlikeSort $auxlist] 690 set auxlist {} 691 foreach x $sorted { 692 lappend auxlist [lindex $x 1] 693 } 694 695 assert_encoding $encoding myzset 696 set fromredis [r zrange myzset 0 -1] 697 set delta 0 698 for {set i 0} {$i < [llength $fromredis]} {incr i} { 699 if {[lindex $fromredis $i] != [lindex $auxlist $i]} { 700 incr delta 701 } 702 } 703 } 704 assert_equal 0 $delta 705 } 706 707 test "ZRANGEBYSCORE fuzzy test, 100 ranges in $elements element sorted set - $encoding" { 708 set err {} 709 r del zset 710 for {set i 0} {$i < $elements} {incr i} { 711 r zadd zset [expr rand()] $i 712 } 713 714 assert_encoding $encoding zset 715 for {set i 0} {$i < 100} {incr i} { 716 set min [expr rand()] 717 set max [expr rand()] 718 if {$min > $max} { 719 set aux $min 720 set min $max 721 set max $aux 722 } 723 set low [r zrangebyscore zset -inf $min] 724 set ok [r zrangebyscore zset $min $max] 725 set high [r zrangebyscore zset $max +inf] 726 set lowx [r zrangebyscore zset -inf ($min] 727 set okx [r zrangebyscore zset ($min ($max] 728 set highx [r zrangebyscore zset ($max +inf] 729 730 if {[r zcount zset -inf $min] != [llength $low]} { 731 append err "Error, len does not match zcount\n" 732 } 733 if {[r zcount zset $min $max] != [llength $ok]} { 734 append err "Error, len does not match zcount\n" 735 } 736 if {[r zcount zset $max +inf] != [llength $high]} { 737 append err "Error, len does not match zcount\n" 738 } 739 if {[r zcount zset -inf ($min] != [llength $lowx]} { 740 append err "Error, len does not match zcount\n" 741 } 742 if {[r zcount zset ($min ($max] != [llength $okx]} { 743 append err "Error, len does not match zcount\n" 744 } 745 if {[r zcount zset ($max +inf] != [llength $highx]} { 746 append err "Error, len does not match zcount\n" 747 } 748 749 foreach x $low { 750 set score [r zscore zset $x] 751 if {$score > $min} { 752 append err "Error, score for $x is $score > $min\n" 753 } 754 } 755 foreach x $lowx { 756 set score [r zscore zset $x] 757 if {$score >= $min} { 758 append err "Error, score for $x is $score >= $min\n" 759 } 760 } 761 foreach x $ok { 762 set score [r zscore zset $x] 763 if {$score < $min || $score > $max} { 764 append err "Error, score for $x is $score outside $min-$max range\n" 765 } 766 } 767 foreach x $okx { 768 set score [r zscore zset $x] 769 if {$score <= $min || $score >= $max} { 770 append err "Error, score for $x is $score outside $min-$max open range\n" 771 } 772 } 773 foreach x $high { 774 set score [r zscore zset $x] 775 if {$score < $max} { 776 append err "Error, score for $x is $score < $max\n" 777 } 778 } 779 foreach x $highx { 780 set score [r zscore zset $x] 781 if {$score <= $max} { 782 append err "Error, score for $x is $score <= $max\n" 783 } 784 } 785 } 786 assert_equal {} $err 787 } 788 789 test "ZRANGEBYLEX fuzzy test, 100 ranges in $elements element sorted set - $encoding" { 790 set lexset {} 791 r del zset 792 for {set j 0} {$j < $elements} {incr j} { 793 set e [randstring 0 30 alpha] 794 lappend lexset $e 795 r zadd zset 0 $e 796 } 797 set lexset [lsort -unique $lexset] 798 for {set j 0} {$j < 100} {incr j} { 799 set min [randstring 0 30 alpha] 800 set max [randstring 0 30 alpha] 801 set mininc [randomInt 2] 802 set maxinc [randomInt 2] 803 if {$mininc} {set cmin "\[$min"} else {set cmin "($min"} 804 if {$maxinc} {set cmax "\[$max"} else {set cmax "($max"} 805 set rev [randomInt 2] 806 if {$rev} { 807 set cmd zrevrangebylex 808 } else { 809 set cmd zrangebylex 810 } 811 812 # Make sure data is the same in both sides 813 assert {[r zrange zset 0 -1] eq $lexset} 814 815 # Get the Redis output 816 set output [r $cmd zset $cmin $cmax] 817 if {$rev} { 818 set outlen [r zlexcount zset $cmax $cmin] 819 } else { 820 set outlen [r zlexcount zset $cmin $cmax] 821 } 822 823 # Compute the same output via Tcl 824 set o {} 825 set copy $lexset 826 if {(!$rev && [string compare $min $max] > 0) || 827 ($rev && [string compare $max $min] > 0)} { 828 # Empty output when ranges are inverted. 829 } else { 830 if {$rev} { 831 # Invert the Tcl array using Redis itself. 832 set copy [r zrevrange zset 0 -1] 833 # Invert min / max as well 834 lassign [list $min $max $mininc $maxinc] \ 835 max min maxinc mininc 836 } 837 foreach e $copy { 838 set mincmp [string compare $e $min] 839 set maxcmp [string compare $e $max] 840 if { 841 ($mininc && $mincmp >= 0 || !$mininc && $mincmp > 0) 842 && 843 ($maxinc && $maxcmp <= 0 || !$maxinc && $maxcmp < 0) 844 } { 845 lappend o $e 846 } 847 } 848 } 849 assert {$o eq $output} 850 assert {$outlen eq [llength $output]} 851 } 852 } 853 854 test "ZREMRANGEBYLEX fuzzy test, 100 ranges in $elements element sorted set - $encoding" { 855 set lexset {} 856 r del zset zsetcopy 857 for {set j 0} {$j < $elements} {incr j} { 858 set e [randstring 0 30 alpha] 859 lappend lexset $e 860 r zadd zset 0 $e 861 } 862 set lexset [lsort -unique $lexset] 863 for {set j 0} {$j < 100} {incr j} { 864 # Copy... 865 r zunionstore zsetcopy 1 zset 866 set lexsetcopy $lexset 867 868 set min [randstring 0 30 alpha] 869 set max [randstring 0 30 alpha] 870 set mininc [randomInt 2] 871 set maxinc [randomInt 2] 872 if {$mininc} {set cmin "\[$min"} else {set cmin "($min"} 873 if {$maxinc} {set cmax "\[$max"} else {set cmax "($max"} 874 875 # Make sure data is the same in both sides 876 assert {[r zrange zset 0 -1] eq $lexset} 877 878 # Get the range we are going to remove 879 set torem [r zrangebylex zset $cmin $cmax] 880 set toremlen [r zlexcount zset $cmin $cmax] 881 r zremrangebylex zsetcopy $cmin $cmax 882 set output [r zrange zsetcopy 0 -1] 883 884 # Remove the range with Tcl from the original list 885 if {$toremlen} { 886 set first [lsearch -exact $lexsetcopy [lindex $torem 0]] 887 set last [expr {$first+$toremlen-1}] 888 set lexsetcopy [lreplace $lexsetcopy $first $last] 889 } 890 assert {$lexsetcopy eq $output} 891 } 892 } 893 894 test "ZSETs skiplist implementation backlink consistency test - $encoding" { 895 set diff 0 896 for {set j 0} {$j < $elements} {incr j} { 897 r zadd myzset [expr rand()] "Element-$j" 898 r zrem myzset "Element-[expr int(rand()*$elements)]" 899 } 900 901 assert_encoding $encoding myzset 902 set l1 [r zrange myzset 0 -1] 903 set l2 [r zrevrange myzset 0 -1] 904 for {set j 0} {$j < [llength $l1]} {incr j} { 905 if {[lindex $l1 $j] ne [lindex $l2 end-$j]} { 906 incr diff 907 } 908 } 909 assert_equal 0 $diff 910 } 911 912 test "ZSETs ZRANK augmented skip list stress testing - $encoding" { 913 set err {} 914 r del myzset 915 for {set k 0} {$k < 2000} {incr k} { 916 set i [expr {$k % $elements}] 917 if {[expr rand()] < .2} { 918 r zrem myzset $i 919 } else { 920 set score [expr rand()] 921 r zadd myzset $score $i 922 assert_encoding $encoding myzset 923 } 924 925 set card [r zcard myzset] 926 if {$card > 0} { 927 set index [randomInt $card] 928 set ele [lindex [r zrange myzset $index $index] 0] 929 set rank [r zrank myzset $ele] 930 if {$rank != $index} { 931 set err "$ele RANK is wrong! ($rank != $index)" 932 break 933 } 934 } 935 } 936 assert_equal {} $err 937 } 938 } 939 940 tags {"slow"} { 941 stressers ziplist 942 stressers skiplist 943 } 944} 945