1 /* 2 * Hunt - A redis client library for D programming language. 3 * 4 * Copyright (C) 2018-2019 HuntLabs 5 * 6 * Website: https://www.huntlabs.net/ 7 * 8 * Licensed under the Apache-2.0 License. 9 * 10 */ 11 12 module hunt.redis.RedisCluster; 13 14 15 import hunt.redis.BinaryRedisCluster; 16 import hunt.redis.Redis; 17 import hunt.redis.RedisClusterCommand; 18 import hunt.redis.HostAndPort; 19 import hunt.redis.Protocol; 20 import hunt.redis.RedisClusterConnectionHandler; 21 import hunt.redis.RedisPoolOptions; 22 import hunt.redis.params.GeoRadiusParam; 23 import hunt.redis.params.SetParams; 24 import hunt.redis.params.ZAddParams; 25 import hunt.redis.params.ZIncrByParams; 26 import hunt.redis.commands.RedisClusterCommands; 27 import hunt.redis.commands.RedisClusterScriptingCommands; 28 import hunt.redis.commands.MultiKeyRedisClusterCommands; 29 import hunt.redis.util.RedisClusterHashTagUtil; 30 import hunt.redis.util.KeyMergeUtil; 31 32 import hunt.collection.Collections; 33 import hunt.collection.List; 34 import hunt.collection.Map; 35 import hunt.collection.Set; 36 import hunt.util.pool; 37 38 import hunt.Long; 39 40 41 private template ClusterStringCommandTemplate(string name, R, string[] args) { 42 import std.format; 43 44 enum string statementBlock = q{ 45 scope RedisClusterCommand!(%2$s) command = 46 new class(connectionHandler, maxAttempts) RedisClusterCommand!(%2$s) { 47 48 this(RedisClusterConnectionHandler connectionHandler, int maxAttempts) { 49 super(connectionHandler, maxAttempts); 50 } 51 52 override %2$s execute(Redis connection) { 53 return connection.%1$s(%3$-(%s, %)); 54 } 55 }; 56 57 return command.run(%4$s); 58 }.format(name, R.stringof, args, args[0]); 59 60 // pragma(msg, statementBlock); 61 alias ClusterStringCommandTemplate = statementBlock; 62 } 63 64 /** 65 * 66 */ 67 class RedisCluster : BinaryRedisCluster, RedisClusterCommands, 68 MultiKeyRedisClusterCommands, RedisClusterScriptingCommands { 69 70 this(HostAndPort node, RedisPoolOptions poolConfig) { 71 this([node], poolConfig); 72 } 73 74 this(HostAndPort[] nodes, RedisPoolOptions poolConfig) { 75 super(nodes, poolConfig); 76 } 77 78 override 79 string set(string key, string value) { 80 mixin(ClusterStringCommandTemplate!("set", string, [key.stringof, value.stringof])); 81 } 82 83 override 84 string set(string key, string value, SetParams params) { 85 mixin(ClusterStringCommandTemplate!("set", string, [key.stringof, value.stringof, params.stringof])); 86 } 87 88 override 89 string get(string key) { 90 mixin(ClusterStringCommandTemplate!("get", string, [key.stringof])); 91 } 92 93 override 94 bool exists(string key) { 95 mixin(ClusterStringCommandTemplate!("exists", bool, [key.stringof])); 96 } 97 98 override 99 Long exists(string[] keys...) { 100 mixin(ClusterStringCommandTemplate!("exists", Long, [keys.stringof])); 101 } 102 alias exists = BinaryRedisCluster.exists; 103 104 override 105 Long persist(string key) { 106 mixin(ClusterStringCommandTemplate!("persist", Long, [key.stringof])); 107 } 108 109 override 110 string type(string key) { 111 mixin(ClusterStringCommandTemplate!("type", string, [key.stringof])); 112 } 113 114 // override 115 // byte[] dump(string key) { 116 // return new RedisClusterCommand!(byte[])(connectionHandler, maxAttempts) { 117 // override 118 // byte[] execute(Redis connection) { 119 // return connection.dump(key); 120 // } 121 // }.run(key); 122 // } 123 124 // override 125 // string restore(string key, int ttl, byte[] serializedValue) { 126 // return new RedisClusterCommand!(string)(connectionHandler, maxAttempts) { 127 // override 128 // string execute(Redis connection) { 129 // return connection.restore(key, ttl, serializedValue); 130 // } 131 // }.run(key); 132 // } 133 134 // override 135 // Long expire(string key, int seconds) { 136 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 137 // override 138 // Long execute(Redis connection) { 139 // return connection.expire(key, seconds); 140 // } 141 // }.run(key); 142 // } 143 144 // override 145 // Long pexpire(string key, long milliseconds) { 146 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 147 // override 148 // Long execute(Redis connection) { 149 // return connection.pexpire(key, milliseconds); 150 // } 151 // }.run(key); 152 // } 153 154 // override 155 // Long expireAt(string key, long unixTime) { 156 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 157 // override 158 // Long execute(Redis connection) { 159 // return connection.expireAt(key, unixTime); 160 // } 161 // }.run(key); 162 // } 163 164 // override 165 // Long pexpireAt(string key, long millisecondsTimestamp) { 166 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 167 // override 168 // Long execute(Redis connection) { 169 // return connection.pexpireAt(key, millisecondsTimestamp); 170 // } 171 // }.run(key); 172 // } 173 174 // override 175 // Long ttl(string key) { 176 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 177 // override 178 // Long execute(Redis connection) { 179 // return connection.ttl(key); 180 // } 181 // }.run(key); 182 // } 183 184 // override 185 // Long pttl(string key) { 186 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 187 // override 188 // Long execute(Redis connection) { 189 // return connection.pttl(key); 190 // } 191 // }.run(key); 192 // } 193 194 // override 195 // Long touch(string key) { 196 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 197 // override 198 // Long execute(Redis connection) { 199 // return connection.touch(key); 200 // } 201 // }.run(key); 202 // } 203 204 // override 205 // Long touch(string[] keys...) { 206 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 207 // override 208 // Long execute(Redis connection) { 209 // return connection.touch(keys); 210 // } 211 // }.run(keys.length, keys); 212 // } 213 214 // override 215 // Boolean setbit(string key, long offset, bool value) { 216 // return new RedisClusterCommand!(Boolean)(connectionHandler, maxAttempts) { 217 // override 218 // Boolean execute(Redis connection) { 219 // return connection.setbit(key, offset, value); 220 // } 221 // }.run(key); 222 // } 223 224 // override 225 // Boolean setbit(string key, long offset, string value) { 226 // return new RedisClusterCommand!(Boolean)(connectionHandler, maxAttempts) { 227 // override 228 // Boolean execute(Redis connection) { 229 // return connection.setbit(key, offset, value); 230 // } 231 // }.run(key); 232 // } 233 234 // override 235 // Boolean getbit(string key, long offset) { 236 // return new RedisClusterCommand!(Boolean)(connectionHandler, maxAttempts) { 237 // override 238 // Boolean execute(Redis connection) { 239 // return connection.getbit(key, offset); 240 // } 241 // }.run(key); 242 // } 243 244 // override 245 // Long setrange(string key, long offset, string value) { 246 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 247 // override 248 // Long execute(Redis connection) { 249 // return connection.setrange(key, offset, value); 250 // } 251 // }.run(key); 252 // } 253 254 // override 255 // string getrange(string key, long startOffset, long endOffset) { 256 // return new RedisClusterCommand!(string)(connectionHandler, maxAttempts) { 257 // override 258 // string execute(Redis connection) { 259 // return connection.getrange(key, startOffset, endOffset); 260 // } 261 // }.run(key); 262 // } 263 264 // override 265 // string getSet(string key, string value) { 266 // return new RedisClusterCommand!(string)(connectionHandler, maxAttempts) { 267 // override 268 // string execute(Redis connection) { 269 // return connection.getSet(key, value); 270 // } 271 // }.run(key); 272 // } 273 274 // override 275 // Long setnx(string key, string value) { 276 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 277 // override 278 // Long execute(Redis connection) { 279 // return connection.setnx(key, value); 280 // } 281 // }.run(key); 282 // } 283 284 // override 285 // string setex(string key, int seconds, string value) { 286 // return new RedisClusterCommand!(string)(connectionHandler, maxAttempts) { 287 // override 288 // string execute(Redis connection) { 289 // return connection.setex(key, seconds, value); 290 // } 291 // }.run(key); 292 // } 293 294 // override 295 // string psetex(string key, long milliseconds, string value) { 296 // return new RedisClusterCommand!(string)(connectionHandler, maxAttempts) { 297 // override 298 // string execute(Redis connection) { 299 // return connection.psetex(key, milliseconds, value); 300 // } 301 // }.run(key); 302 // } 303 304 // override 305 // Long decrBy(string key, long decrement) { 306 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 307 // override 308 // Long execute(Redis connection) { 309 // return connection.decrBy(key, decrement); 310 // } 311 // }.run(key); 312 // } 313 314 // override 315 // Long decr(string key) { 316 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 317 // override 318 // Long execute(Redis connection) { 319 // return connection.decr(key); 320 // } 321 // }.run(key); 322 // } 323 324 // override 325 // Long incrBy(string key, long increment) { 326 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 327 // override 328 // Long execute(Redis connection) { 329 // return connection.incrBy(key, increment); 330 // } 331 // }.run(key); 332 // } 333 334 // override 335 // Double incrByFloat(string key, double increment) { 336 // return new RedisClusterCommand!(Double)(connectionHandler, maxAttempts) { 337 // override 338 // Double execute(Redis connection) { 339 // return connection.incrByFloat(key, increment); 340 // } 341 // }.run(key); 342 // } 343 344 // override 345 // Long incr(string key) { 346 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 347 // override 348 // Long execute(Redis connection) { 349 // return connection.incr(key); 350 // } 351 // }.run(key); 352 // } 353 354 // override 355 // Long append(string key, string value) { 356 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 357 // override 358 // Long execute(Redis connection) { 359 // return connection.append(key, value); 360 // } 361 // }.run(key); 362 // } 363 364 // override 365 // string substr(string key, int start, int end) { 366 // return new RedisClusterCommand!(string)(connectionHandler, maxAttempts) { 367 // override 368 // string execute(Redis connection) { 369 // return connection.substr(key, start, end); 370 // } 371 // }.run(key); 372 // } 373 374 // override 375 // Long hset(string key, string field, string value) { 376 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 377 // override 378 // Long execute(Redis connection) { 379 // return connection.hset(key, field, value); 380 // } 381 // }.run(key); 382 // } 383 384 // override 385 // Long hset(string key, Map!(string, string) hash) { 386 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 387 // override 388 // Long execute(Redis connection) { 389 // return connection.hset(key, hash); 390 // } 391 // }.run(key); 392 // } 393 394 // override 395 // string hget(string key, string field) { 396 // return new RedisClusterCommand!(string)(connectionHandler, maxAttempts) { 397 // override 398 // string execute(Redis connection) { 399 // return connection.hget(key, field); 400 // } 401 // }.run(key); 402 // } 403 404 // override 405 // Long hsetnx(string key, string field, string value) { 406 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 407 // override 408 // Long execute(Redis connection) { 409 // return connection.hsetnx(key, field, value); 410 // } 411 // }.run(key); 412 // } 413 414 // override 415 // string hmset(string key, Map!(string, string) hash) { 416 // return new RedisClusterCommand!(string)(connectionHandler, maxAttempts) { 417 // override 418 // string execute(Redis connection) { 419 // return connection.hmset(key, hash); 420 // } 421 // }.run(key); 422 // } 423 424 // override 425 // List!(string) hmget(string key, string[] fields...) { 426 // return new RedisClusterCommand!(List!(string))(connectionHandler, maxAttempts) { 427 // override 428 // List!(string) execute(Redis connection) { 429 // return connection.hmget(key, fields); 430 // } 431 // }.run(key); 432 // } 433 434 // override 435 // Long hincrBy(string key, string field, long value) { 436 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 437 // override 438 // Long execute(Redis connection) { 439 // return connection.hincrBy(key, field, value); 440 // } 441 // }.run(key); 442 // } 443 444 // override 445 // Boolean hexists(string key, string field) { 446 // return new RedisClusterCommand!(Boolean)(connectionHandler, maxAttempts) { 447 // override 448 // Boolean execute(Redis connection) { 449 // return connection.hexists(key, field); 450 // } 451 // }.run(key); 452 // } 453 454 // override 455 // Long hdel(string key, string[] field...) { 456 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 457 // override 458 // Long execute(Redis connection) { 459 // return connection.hdel(key, field); 460 // } 461 // }.run(key); 462 // } 463 464 // override 465 // Long hlen(string key) { 466 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 467 // override 468 // Long execute(Redis connection) { 469 // return connection.hlen(key); 470 // } 471 // }.run(key); 472 // } 473 474 // override 475 // Set!(string) hkeys(string key) { 476 // return new RedisClusterCommand!(Set!(string))(connectionHandler, maxAttempts) { 477 // override 478 // Set!(string) execute(Redis connection) { 479 // return connection.hkeys(key); 480 // } 481 // }.run(key); 482 // } 483 484 // override 485 // List!(string) hvals(string key) { 486 // return new RedisClusterCommand!(List!(string))(connectionHandler, maxAttempts) { 487 // override 488 // List!(string) execute(Redis connection) { 489 // return connection.hvals(key); 490 // } 491 // }.run(key); 492 // } 493 494 // override 495 // Map!(string, string) hgetAll(string key) { 496 // return new RedisClusterCommand!(Map!(string, string))(connectionHandler, maxAttempts) { 497 // override 498 // Map!(string, string) execute(Redis connection) { 499 // return connection.hgetAll(key); 500 // } 501 // }.run(key); 502 // } 503 504 // override 505 // Long rpush(string key, string[] string...) { 506 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 507 // override 508 // Long execute(Redis connection) { 509 // return connection.rpush(key, string); 510 // } 511 // }.run(key); 512 // } 513 514 // override 515 // Long lpush(string key, string[] string...) { 516 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 517 // override 518 // Long execute(Redis connection) { 519 // return connection.lpush(key, string); 520 // } 521 // }.run(key); 522 // } 523 524 // override 525 // Long llen(string key) { 526 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 527 // override 528 // Long execute(Redis connection) { 529 // return connection.llen(key); 530 // } 531 // }.run(key); 532 // } 533 534 // override 535 // List!(string) lrange(string key, long start, long stop) { 536 // return new RedisClusterCommand!(List!(string))(connectionHandler, maxAttempts) { 537 // override 538 // List!(string) execute(Redis connection) { 539 // return connection.lrange(key, start, stop); 540 // } 541 // }.run(key); 542 // } 543 544 // override 545 // string ltrim(string key, long start, long stop) { 546 // return new RedisClusterCommand!(string)(connectionHandler, maxAttempts) { 547 // override 548 // string execute(Redis connection) { 549 // return connection.ltrim(key, start, stop); 550 // } 551 // }.run(key); 552 // } 553 554 // override 555 // string lindex(string key, long index) { 556 // return new RedisClusterCommand!(string)(connectionHandler, maxAttempts) { 557 // override 558 // string execute(Redis connection) { 559 // return connection.lindex(key, index); 560 // } 561 // }.run(key); 562 // } 563 564 // override 565 // string lset(string key, long index, string value) { 566 // return new RedisClusterCommand!(string)(connectionHandler, maxAttempts) { 567 // override 568 // string execute(Redis connection) { 569 // return connection.lset(key, index, value); 570 // } 571 // }.run(key); 572 // } 573 574 // override 575 // Long lrem(string key, long count, string value) { 576 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 577 // override 578 // Long execute(Redis connection) { 579 // return connection.lrem(key, count, value); 580 // } 581 // }.run(key); 582 // } 583 584 // override 585 // string lpop(string key) { 586 // return new RedisClusterCommand!(string)(connectionHandler, maxAttempts) { 587 // override 588 // string execute(Redis connection) { 589 // return connection.lpop(key); 590 // } 591 // }.run(key); 592 // } 593 594 // override 595 // string rpop(string key) { 596 // return new RedisClusterCommand!(string)(connectionHandler, maxAttempts) { 597 // override 598 // string execute(Redis connection) { 599 // return connection.rpop(key); 600 // } 601 // }.run(key); 602 // } 603 604 // override 605 // Long sadd(string key, string[] member...) { 606 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 607 // override 608 // Long execute(Redis connection) { 609 // return connection.sadd(key, member); 610 // } 611 // }.run(key); 612 // } 613 614 // override 615 // Set!(string) smembers(string key) { 616 // return new RedisClusterCommand!(Set!(string))(connectionHandler, maxAttempts) { 617 // override 618 // Set!(string) execute(Redis connection) { 619 // return connection.smembers(key); 620 // } 621 // }.run(key); 622 // } 623 624 // override 625 // Long srem(string key, string[] member...) { 626 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 627 // override 628 // Long execute(Redis connection) { 629 // return connection.srem(key, member); 630 // } 631 // }.run(key); 632 // } 633 634 // override 635 // string spop(string key) { 636 // return new RedisClusterCommand!(string)(connectionHandler, maxAttempts) { 637 // override 638 // string execute(Redis connection) { 639 // return connection.spop(key); 640 // } 641 // }.run(key); 642 // } 643 644 // override 645 // Set!(string) spop(string key, long count) { 646 // return new RedisClusterCommand!(Set!(string))(connectionHandler, maxAttempts) { 647 // override 648 // Set!(string) execute(Redis connection) { 649 // return connection.spop(key, count); 650 // } 651 // }.run(key); 652 // } 653 654 // override 655 // Long scard(string key) { 656 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 657 // override 658 // Long execute(Redis connection) { 659 // return connection.scard(key); 660 // } 661 // }.run(key); 662 // } 663 664 // override 665 // Boolean sismember(string key, string member) { 666 // return new RedisClusterCommand!(Boolean)(connectionHandler, maxAttempts) { 667 // override 668 // Boolean execute(Redis connection) { 669 // return connection.sismember(key, member); 670 // } 671 // }.run(key); 672 // } 673 674 // override 675 // string srandmember(string key) { 676 // return new RedisClusterCommand!(string)(connectionHandler, maxAttempts) { 677 // override 678 // string execute(Redis connection) { 679 // return connection.srandmember(key); 680 // } 681 // }.run(key); 682 // } 683 684 // override 685 // List!(string) srandmember(string key, int count) { 686 // return new RedisClusterCommand!(List!(string))(connectionHandler, maxAttempts) { 687 // override 688 // List!(string) execute(Redis connection) { 689 // return connection.srandmember(key, count); 690 // } 691 // }.run(key); 692 // } 693 694 // override 695 // Long strlen(string key) { 696 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 697 // override 698 // Long execute(Redis connection) { 699 // return connection.strlen(key); 700 // } 701 // }.run(key); 702 // } 703 704 // override 705 // Long zadd(string key, double score, string member) { 706 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 707 // override 708 // Long execute(Redis connection) { 709 // return connection.zadd(key, score, member); 710 // } 711 // }.run(key); 712 // } 713 714 // override 715 // Long zadd(string key, double score, string member, 716 // ZAddParams params) { 717 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 718 // override 719 // Long execute(Redis connection) { 720 // return connection.zadd(key, score, member, params); 721 // } 722 // }.run(key); 723 // } 724 725 // override 726 // Long zadd(string key, Map!(string, double) scoreMembers) { 727 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 728 // override 729 // Long execute(Redis connection) { 730 // return connection.zadd(key, scoreMembers); 731 // } 732 // }.run(key); 733 // } 734 735 // override 736 // Long zadd(string key, Map!(string, double) scoreMembers, ZAddParams params) { 737 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 738 // override 739 // Long execute(Redis connection) { 740 // return connection.zadd(key, scoreMembers, params); 741 // } 742 // }.run(key); 743 // } 744 745 // override 746 // Set!(string) zrange(string key, long start, long stop) { 747 // return new RedisClusterCommand!(Set!(string))(connectionHandler, maxAttempts) { 748 // override 749 // Set!(string) execute(Redis connection) { 750 // return connection.zrange(key, start, stop); 751 // } 752 // }.run(key); 753 // } 754 755 // override 756 // Long zrem(string key, string[] members...) { 757 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 758 // override 759 // Long execute(Redis connection) { 760 // return connection.zrem(key, members); 761 // } 762 // }.run(key); 763 // } 764 765 // override 766 // Double zincrby(string key, double increment, string member) { 767 // return new RedisClusterCommand!(Double)(connectionHandler, maxAttempts) { 768 // override 769 // Double execute(Redis connection) { 770 // return connection.zincrby(key, increment, member); 771 // } 772 // }.run(key); 773 // } 774 775 // override 776 // Double zincrby(string key, double increment, string member, 777 // ZIncrByParams params) { 778 // return new RedisClusterCommand!(Double)(connectionHandler, maxAttempts) { 779 // override 780 // Double execute(Redis connection) { 781 // return connection.zincrby(key, increment, member, params); 782 // } 783 // }.run(key); 784 // } 785 786 // override 787 // Long zrank(string key, string member) { 788 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 789 // override 790 // Long execute(Redis connection) { 791 // return connection.zrank(key, member); 792 // } 793 // }.run(key); 794 // } 795 796 // override 797 // Long zrevrank(string key, string member) { 798 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 799 // override 800 // Long execute(Redis connection) { 801 // return connection.zrevrank(key, member); 802 // } 803 // }.run(key); 804 // } 805 806 // override 807 // Set!(string) zrevrange(string key, long start, long stop) { 808 // return new RedisClusterCommand!(Set!(string))(connectionHandler, maxAttempts) { 809 // override 810 // Set!(string) execute(Redis connection) { 811 // return connection.zrevrange(key, start, stop); 812 // } 813 // }.run(key); 814 // } 815 816 // override 817 // Set!(Tuple) zrangeWithScores(string key, long start, long stop) { 818 // return new RedisClusterCommand!(Set!(Tuple))(connectionHandler, maxAttempts) { 819 // override 820 // Set!(Tuple) execute(Redis connection) { 821 // return connection.zrangeWithScores(key, start, stop); 822 // } 823 // }.run(key); 824 // } 825 826 // override 827 // Set!(Tuple) zrevrangeWithScores(string key, long start, long stop) { 828 // return new RedisClusterCommand!(Set!(Tuple))(connectionHandler, maxAttempts) { 829 // override 830 // Set!(Tuple) execute(Redis connection) { 831 // return connection.zrevrangeWithScores(key, start, stop); 832 // } 833 // }.run(key); 834 // } 835 836 // override 837 // Long zcard(string key) { 838 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 839 // override 840 // Long execute(Redis connection) { 841 // return connection.zcard(key); 842 // } 843 // }.run(key); 844 // } 845 846 // override 847 // Double zscore(string key, string member) { 848 // return new RedisClusterCommand!(Double)(connectionHandler, maxAttempts) { 849 // override 850 // Double execute(Redis connection) { 851 // return connection.zscore(key, member); 852 // } 853 // }.run(key); 854 // } 855 856 // override 857 // List!(string) sort(string key) { 858 // return new RedisClusterCommand!(List!(string))(connectionHandler, maxAttempts) { 859 // override 860 // List!(string) execute(Redis connection) { 861 // return connection.sort(key); 862 // } 863 // }.run(key); 864 // } 865 866 // override 867 // List!(string) sort(string key, SortingParams sortingParameters) { 868 // return new RedisClusterCommand!(List!(string))(connectionHandler, maxAttempts) { 869 // override 870 // List!(string) execute(Redis connection) { 871 // return connection.sort(key, sortingParameters); 872 // } 873 // }.run(key); 874 // } 875 876 // override 877 // Long zcount(string key, double min, double max) { 878 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 879 // override 880 // Long execute(Redis connection) { 881 // return connection.zcount(key, min, max); 882 // } 883 // }.run(key); 884 // } 885 886 // override 887 // Long zcount(string key, string min, string max) { 888 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 889 // override 890 // Long execute(Redis connection) { 891 // return connection.zcount(key, min, max); 892 // } 893 // }.run(key); 894 // } 895 896 // override 897 // Set!(string) zrangeByScore(string key, double min, double max) { 898 // return new RedisClusterCommand!(Set!(string))(connectionHandler, maxAttempts) { 899 // override 900 // Set!(string) execute(Redis connection) { 901 // return connection.zrangeByScore(key, min, max); 902 // } 903 // }.run(key); 904 // } 905 906 // override 907 // Set!(string) zrangeByScore(string key, string min, string max) { 908 // return new RedisClusterCommand!(Set!(string))(connectionHandler, maxAttempts) { 909 // override 910 // Set!(string) execute(Redis connection) { 911 // return connection.zrangeByScore(key, min, max); 912 // } 913 // }.run(key); 914 // } 915 916 // override 917 // Set!(string) zrevrangeByScore(string key, double max, double min) { 918 // return new RedisClusterCommand!(Set!(string))(connectionHandler, maxAttempts) { 919 // override 920 // Set!(string) execute(Redis connection) { 921 // return connection.zrevrangeByScore(key, max, min); 922 // } 923 // }.run(key); 924 // } 925 926 // override 927 // Set!(string) zrangeByScore(string key, double min, double max, 928 // int offset, int count) { 929 // return new RedisClusterCommand!(Set!(string))(connectionHandler, maxAttempts) { 930 // override 931 // Set!(string) execute(Redis connection) { 932 // return connection.zrangeByScore(key, min, max, offset, count); 933 // } 934 // }.run(key); 935 // } 936 937 // override 938 // Set!(string) zrevrangeByScore(string key, string max, string min) { 939 // return new RedisClusterCommand!(Set!(string))(connectionHandler, maxAttempts) { 940 // override 941 // Set!(string) execute(Redis connection) { 942 // return connection.zrevrangeByScore(key, max, min); 943 // } 944 // }.run(key); 945 // } 946 947 // override 948 // Set!(string) zrangeByScore(string key, string min, string max, 949 // int offset, int count) { 950 // return new RedisClusterCommand!(Set!(string))(connectionHandler, maxAttempts) { 951 // override 952 // Set!(string) execute(Redis connection) { 953 // return connection.zrangeByScore(key, min, max, offset, count); 954 // } 955 // }.run(key); 956 // } 957 958 // override 959 // Set!(string) zrevrangeByScore(string key, double max, double min, 960 // int offset, int count) { 961 // return new RedisClusterCommand!(Set!(string))(connectionHandler, maxAttempts) { 962 // override 963 // Set!(string) execute(Redis connection) { 964 // return connection.zrevrangeByScore(key, max, min, offset, count); 965 // } 966 // }.run(key); 967 // } 968 969 // override 970 // Set!(Tuple) zrangeByScoreWithScores(string key, double min, double max) { 971 // return new RedisClusterCommand!(Set!(Tuple))(connectionHandler, maxAttempts) { 972 // override 973 // Set!(Tuple) execute(Redis connection) { 974 // return connection.zrangeByScoreWithScores(key, min, max); 975 // } 976 // }.run(key); 977 // } 978 979 // override 980 // Set!(Tuple) zrevrangeByScoreWithScores(string key, double max, double min) { 981 // return new RedisClusterCommand!(Set!(Tuple))(connectionHandler, maxAttempts) { 982 // override 983 // Set!(Tuple) execute(Redis connection) { 984 // return connection.zrevrangeByScoreWithScores(key, max, min); 985 // } 986 // }.run(key); 987 // } 988 989 // override 990 // Set!(Tuple) zrangeByScoreWithScores(string key, double min, double max, 991 // int offset, int count) { 992 // return new RedisClusterCommand!(Set!(Tuple))(connectionHandler, maxAttempts) { 993 // override 994 // Set!(Tuple) execute(Redis connection) { 995 // return connection.zrangeByScoreWithScores(key, min, max, offset, count); 996 // } 997 // }.run(key); 998 // } 999 1000 // override 1001 // Set!(string) zrevrangeByScore(string key, string max, string min, 1002 // int offset, int count) { 1003 // return new RedisClusterCommand!(Set!(string))(connectionHandler, maxAttempts) { 1004 // override 1005 // Set!(string) execute(Redis connection) { 1006 // return connection.zrevrangeByScore(key, max, min, offset, count); 1007 // } 1008 // }.run(key); 1009 // } 1010 1011 // override 1012 // Set!(Tuple) zrangeByScoreWithScores(string key, string min, string max) { 1013 // return new RedisClusterCommand!(Set!(Tuple))(connectionHandler, maxAttempts) { 1014 // override 1015 // Set!(Tuple) execute(Redis connection) { 1016 // return connection.zrangeByScoreWithScores(key, min, max); 1017 // } 1018 // }.run(key); 1019 // } 1020 1021 // override 1022 // Set!(Tuple) zrevrangeByScoreWithScores(string key, string max, string min) { 1023 // return new RedisClusterCommand!(Set!(Tuple))(connectionHandler, maxAttempts) { 1024 // override 1025 // Set!(Tuple) execute(Redis connection) { 1026 // return connection.zrevrangeByScoreWithScores(key, max, min); 1027 // } 1028 // }.run(key); 1029 // } 1030 1031 // override 1032 // Set!(Tuple) zrangeByScoreWithScores(string key, string min, string max, 1033 // int offset, int count) { 1034 // return new RedisClusterCommand!(Set!(Tuple))(connectionHandler, maxAttempts) { 1035 // override 1036 // Set!(Tuple) execute(Redis connection) { 1037 // return connection.zrangeByScoreWithScores(key, min, max, offset, count); 1038 // } 1039 // }.run(key); 1040 // } 1041 1042 // override 1043 // Set!(Tuple) zrevrangeByScoreWithScores(string key, double max, 1044 // double min, int offset, int count) { 1045 // return new RedisClusterCommand!(Set!(Tuple))(connectionHandler, maxAttempts) { 1046 // override 1047 // Set!(Tuple) execute(Redis connection) { 1048 // return connection.zrevrangeByScoreWithScores(key, max, min, offset, count); 1049 // } 1050 // }.run(key); 1051 // } 1052 1053 // override 1054 // Set!(Tuple) zrevrangeByScoreWithScores(string key, string max, 1055 // string min, int offset, int count) { 1056 // return new RedisClusterCommand!(Set!(Tuple))(connectionHandler, maxAttempts) { 1057 // override 1058 // Set!(Tuple) execute(Redis connection) { 1059 // return connection.zrevrangeByScoreWithScores(key, max, min, offset, count); 1060 // } 1061 // }.run(key); 1062 // } 1063 1064 // override 1065 // Long zremrangeByRank(string key, long start, long stop) { 1066 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 1067 // override 1068 // Long execute(Redis connection) { 1069 // return connection.zremrangeByRank(key, start, stop); 1070 // } 1071 // }.run(key); 1072 // } 1073 1074 // override 1075 // Long zremrangeByScore(string key, double min, double max) { 1076 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 1077 // override 1078 // Long execute(Redis connection) { 1079 // return connection.zremrangeByScore(key, min, max); 1080 // } 1081 // }.run(key); 1082 // } 1083 1084 // override 1085 // Long zremrangeByScore(string key, string min, string max) { 1086 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 1087 // override 1088 // Long execute(Redis connection) { 1089 // return connection.zremrangeByScore(key, min, max); 1090 // } 1091 // }.run(key); 1092 // } 1093 1094 // override 1095 // Long zlexcount(string key, string min, string max) { 1096 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 1097 // override 1098 // Long execute(Redis connection) { 1099 // return connection.zlexcount(key, min, max); 1100 // } 1101 // }.run(key); 1102 // } 1103 1104 // override 1105 // Set!(string) zrangeByLex(string key, string min, string max) { 1106 // return new RedisClusterCommand!(Set!(string))(connectionHandler, maxAttempts) { 1107 // override 1108 // Set!(string) execute(Redis connection) { 1109 // return connection.zrangeByLex(key, min, max); 1110 // } 1111 // }.run(key); 1112 // } 1113 1114 // override 1115 // Set!(string) zrangeByLex(string key, string min, string max, 1116 // int offset, int count) { 1117 // return new RedisClusterCommand!(Set!(string))(connectionHandler, maxAttempts) { 1118 // override 1119 // Set!(string) execute(Redis connection) { 1120 // return connection.zrangeByLex(key, min, max, offset, count); 1121 // } 1122 // }.run(key); 1123 // } 1124 1125 // override 1126 // Set!(string) zrevrangeByLex(string key, string max, string min) { 1127 // return new RedisClusterCommand!(Set!(string))(connectionHandler, maxAttempts) { 1128 // override 1129 // Set!(string) execute(Redis connection) { 1130 // return connection.zrevrangeByLex(key, max, min); 1131 // } 1132 // }.run(key); 1133 // } 1134 1135 // override 1136 // Set!(string) zrevrangeByLex(string key, string max, string min, 1137 // int offset, int count) { 1138 // return new RedisClusterCommand!(Set!(string))(connectionHandler, maxAttempts) { 1139 // override 1140 // Set!(string) execute(Redis connection) { 1141 // return connection.zrevrangeByLex(key, max, min, offset, count); 1142 // } 1143 // }.run(key); 1144 // } 1145 1146 // override 1147 // Long zremrangeByLex(string key, string min, string max) { 1148 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 1149 // override 1150 // Long execute(Redis connection) { 1151 // return connection.zremrangeByLex(key, min, max); 1152 // } 1153 // }.run(key); 1154 // } 1155 1156 // override 1157 // Long linsert(string key, ListPosition where, string pivot, 1158 // string value) { 1159 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 1160 // override 1161 // Long execute(Redis connection) { 1162 // return connection.linsert(key, where, pivot, value); 1163 // } 1164 // }.run(key); 1165 // } 1166 1167 // override 1168 // Long lpushx(string key, string[] string...) { 1169 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 1170 // override 1171 // Long execute(Redis connection) { 1172 // return connection.lpushx(key, string); 1173 // } 1174 // }.run(key); 1175 // } 1176 1177 // override 1178 // Long rpushx(string key, string[] string...) { 1179 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 1180 // override 1181 // Long execute(Redis connection) { 1182 // return connection.rpushx(key, string); 1183 // } 1184 // }.run(key); 1185 // } 1186 1187 override 1188 Long del(string key) { 1189 mixin(ClusterStringCommandTemplate!("del", Long, [key.stringof])); 1190 } 1191 1192 override 1193 Long del(string[] keys...) { 1194 mixin(ClusterStringCommandTemplate!("del", Long, [keys.stringof])); 1195 } 1196 alias del = BinaryRedisCluster.del; 1197 1198 override 1199 Long unlink(string key) { 1200 mixin(ClusterStringCommandTemplate!("unlink", Long, [key.stringof])); 1201 } 1202 1203 override 1204 Long unlink(string[] keys...) { 1205 mixin(ClusterStringCommandTemplate!("unlink", Long, [keys.stringof])); 1206 } 1207 alias unlink = BinaryRedisCluster.unlink; 1208 1209 // override 1210 // string echo(string string) { 1211 // // note that it'll be run from arbitrary node 1212 // return new RedisClusterCommand!(string)(connectionHandler, maxAttempts) { 1213 // override 1214 // string execute(Redis connection) { 1215 // return connection.echo(string); 1216 // } 1217 // }.run(string); 1218 // } 1219 1220 // override 1221 // Long bitcount(string key) { 1222 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 1223 // override 1224 // Long execute(Redis connection) { 1225 // return connection.bitcount(key); 1226 // } 1227 // }.run(key); 1228 // } 1229 1230 // override 1231 // Long bitcount(string key, long start, long end) { 1232 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 1233 // override 1234 // Long execute(Redis connection) { 1235 // return connection.bitcount(key, start, end); 1236 // } 1237 // }.run(key); 1238 // } 1239 1240 // override 1241 // Set!(string) keys(string pattern) { 1242 // if (pattern is null || pattern.isEmpty()) { 1243 // throw new IllegalArgumentException(this.getClass().getSimpleName() 1244 // ~ " only supports KEYS commands with non-empty patterns"); 1245 // } 1246 // if (!RedisClusterHashTagUtil.isClusterCompliantMatchPattern(pattern)) { 1247 // throw new IllegalArgumentException(this.getClass().getSimpleName() 1248 // ~ " only supports KEYS commands with patterns containing hash-tags ( curly-brackets enclosed strings )"); 1249 // } 1250 // return new RedisClusterCommand!(Set!(string))(connectionHandler, maxAttempts) { 1251 // override 1252 // Set!(string) execute(Redis connection) { 1253 // return connection.keys(pattern); 1254 // } 1255 // }.run(pattern); 1256 // } 1257 1258 // override 1259 // ScanResult!(string) scan(string cursor, ScanParams params) { 1260 1261 // string matchPattern = null; 1262 1263 // if (params is null || (matchPattern = params.match()) is null || matchPattern.isEmpty()) { 1264 // throw new IllegalArgumentException(RedisCluster.class.getSimpleName() 1265 // ~ " only supports SCAN commands with non-empty MATCH patterns"); 1266 // } 1267 1268 // if (!RedisClusterHashTagUtil.isClusterCompliantMatchPattern(matchPattern)) { 1269 // throw new IllegalArgumentException(RedisCluster.class.getSimpleName() 1270 // ~ " only supports SCAN commands with MATCH patterns containing hash-tags ( curly-brackets enclosed strings )"); 1271 // } 1272 1273 // return new RedisClusterCommand!( ScanResult!(string))(connectionHandler, maxAttempts) { 1274 // override 1275 // ScanResult!(string) execute(Redis connection) { 1276 // return connection.scan(cursor, params); 1277 // } 1278 // }.run(matchPattern); 1279 // } 1280 1281 // override 1282 // ScanResult!(Entry!(string, string)) hscan(string key, string cursor) { 1283 // return new RedisClusterCommand!(ScanResult!(Entry!(string, string)))(connectionHandler, 1284 // maxAttempts) { 1285 // override 1286 // ScanResult!(Entry!(string, string)) execute(Redis connection) { 1287 // return connection.hscan(key, cursor); 1288 // } 1289 // }.run(key); 1290 // } 1291 1292 // override 1293 // ScanResult!(string) sscan(string key, string cursor) { 1294 // return new RedisClusterCommand!(ScanResult!(string))(connectionHandler, maxAttempts) { 1295 // override 1296 // ScanResult!(string) execute(Redis connection) { 1297 // return connection.sscan(key, cursor); 1298 // } 1299 // }.run(key); 1300 // } 1301 1302 // override 1303 // ScanResult!(Tuple) zscan(string key, string cursor) { 1304 // return new RedisClusterCommand!(ScanResult!(Tuple))(connectionHandler, maxAttempts) { 1305 // override 1306 // ScanResult!(Tuple) execute(Redis connection) { 1307 // return connection.zscan(key, cursor); 1308 // } 1309 // }.run(key); 1310 // } 1311 1312 // override 1313 // Long pfadd(string key, string[] elements...) { 1314 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 1315 // override 1316 // Long execute(Redis connection) { 1317 // return connection.pfadd(key, elements); 1318 // } 1319 // }.run(key); 1320 // } 1321 1322 // override 1323 // long pfcount(string key) { 1324 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 1325 // override 1326 // Long execute(Redis connection) { 1327 // return connection.pfcount(key); 1328 // } 1329 // }.run(key); 1330 // } 1331 1332 // override 1333 // List!(string) blpop(int timeout, string key) { 1334 // return new RedisClusterCommand!(List!(string))(connectionHandler, maxAttempts) { 1335 // override 1336 // List!(string) execute(Redis connection) { 1337 // return connection.blpop(timeout, key); 1338 // } 1339 // }.run(key); 1340 // } 1341 1342 // override 1343 // List!(string) brpop(int timeout, string key) { 1344 // return new RedisClusterCommand!(List!(string))(connectionHandler, maxAttempts) { 1345 // override 1346 // List!(string) execute(Redis connection) { 1347 // return connection.brpop(timeout, key); 1348 // } 1349 // }.run(key); 1350 // } 1351 1352 // override 1353 // List!(string) blpop(int timeout, string[] keys...) { 1354 // return new RedisClusterCommand!(List!(string))(connectionHandler, maxAttempts) { 1355 // override 1356 // List!(string) execute(Redis connection) { 1357 // return connection.blpop(timeout, keys); 1358 // } 1359 // }.run(keys.length, keys); 1360 1361 // } 1362 1363 // override 1364 // List!(string) brpop(int timeout, string[] keys...) { 1365 // return new RedisClusterCommand!(List!(string))(connectionHandler, maxAttempts) { 1366 // override 1367 // List!(string) execute(Redis connection) { 1368 // return connection.brpop(timeout, keys); 1369 // } 1370 // }.run(keys.length, keys); 1371 // } 1372 1373 override 1374 List!(string) mget(string[] keys...) { 1375 mixin(ClusterStringCommandTemplate!("mget", List!(string), [keys.stringof])); 1376 // return new RedisClusterCommand!(List!(string))(connectionHandler, maxAttempts) { 1377 // override 1378 // List!(string) execute(Redis connection) { 1379 // return connection.mget(keys); 1380 // } 1381 // }.run(keys.length, keys); 1382 } 1383 1384 override 1385 string mset(string[] keysvalues...) { 1386 string[] keys = new string[keysvalues.length / 2]; 1387 1388 for (int keyIdx = 0; keyIdx < keys.length; keyIdx++) { 1389 1390 keys[keyIdx] = keysvalues[keyIdx * 2]; 1391 } 1392 1393 mixin(ClusterStringCommandTemplate!("mset", string, [keys.stringof])); 1394 1395 // return new RedisClusterCommand!(string)(connectionHandler, maxAttempts) { 1396 // override 1397 // string execute(Redis connection) { 1398 // return connection.mset(keysvalues); 1399 // } 1400 // }.run(keys.length, keys); 1401 } 1402 1403 // override 1404 // Long msetnx(string[] keysvalues...) { 1405 // string[] keys = new string[keysvalues.length / 2]; 1406 1407 // for (int keyIdx = 0; keyIdx < keys.length; keyIdx++) { 1408 // keys[keyIdx] = keysvalues[keyIdx * 2]; 1409 // } 1410 1411 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 1412 // override 1413 // Long execute(Redis connection) { 1414 // return connection.msetnx(keysvalues); 1415 // } 1416 // }.run(keys.length, keys); 1417 // } 1418 1419 // override 1420 // string rename(string oldkey, string newkey) { 1421 // return new RedisClusterCommand!(string)(connectionHandler, maxAttempts) { 1422 // override 1423 // string execute(Redis connection) { 1424 // return connection.rename(oldkey, newkey); 1425 // } 1426 // }.run(2, oldkey, newkey); 1427 // } 1428 1429 // override 1430 // Long renamenx(string oldkey, string newkey) { 1431 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 1432 // override 1433 // Long execute(Redis connection) { 1434 // return connection.renamenx(oldkey, newkey); 1435 // } 1436 // }.run(2, oldkey, newkey); 1437 // } 1438 1439 // override 1440 // string rpoplpush(string srckey, string dstkey) { 1441 // return new RedisClusterCommand!(string)(connectionHandler, maxAttempts) { 1442 // override 1443 // string execute(Redis connection) { 1444 // return connection.rpoplpush(srckey, dstkey); 1445 // } 1446 // }.run(2, srckey, dstkey); 1447 // } 1448 1449 // override 1450 // Set!(string) sdiff(string[] keys...) { 1451 // return new RedisClusterCommand!(Set!(string))(connectionHandler, maxAttempts) { 1452 // override 1453 // Set!(string) execute(Redis connection) { 1454 // return connection.sdiff(keys); 1455 // } 1456 // }.run(keys.length, keys); 1457 // } 1458 1459 // override 1460 // Long sdiffstore(string dstkey, string[] keys...) { 1461 // string[] mergedKeys = KeyMergeUtil.merge(dstkey, keys); 1462 1463 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 1464 // override 1465 // Long execute(Redis connection) { 1466 // return connection.sdiffstore(dstkey, keys); 1467 // } 1468 // }.run(mergedKeys.length, mergedKeys); 1469 // } 1470 1471 // override 1472 // Set!(string) sinter(string[] keys...) { 1473 // return new RedisClusterCommand!(Set!(string))(connectionHandler, maxAttempts) { 1474 // override 1475 // Set!(string) execute(Redis connection) { 1476 // return connection.sinter(keys); 1477 // } 1478 // }.run(keys.length, keys); 1479 // } 1480 1481 // override 1482 // Long sinterstore(string dstkey, string[] keys...) { 1483 // string[] mergedKeys = KeyMergeUtil.merge(dstkey, keys); 1484 1485 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 1486 // override 1487 // Long execute(Redis connection) { 1488 // return connection.sinterstore(dstkey, keys); 1489 // } 1490 // }.run(mergedKeys.length, mergedKeys); 1491 // } 1492 1493 // override 1494 // Long smove(string srckey, string dstkey, string member) { 1495 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 1496 // override 1497 // Long execute(Redis connection) { 1498 // return connection.smove(srckey, dstkey, member); 1499 // } 1500 // }.run(2, srckey, dstkey); 1501 // } 1502 1503 // override 1504 // Long sort(string key, SortingParams sortingParameters, string dstkey) { 1505 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 1506 // override 1507 // Long execute(Redis connection) { 1508 // return connection.sort(key, sortingParameters, dstkey); 1509 // } 1510 // }.run(2, key, dstkey); 1511 // } 1512 1513 // override 1514 // Long sort(string key, string dstkey) { 1515 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 1516 // override 1517 // Long execute(Redis connection) { 1518 // return connection.sort(key, dstkey); 1519 // } 1520 // }.run(2, key, dstkey); 1521 // } 1522 1523 // override 1524 // Set!(string) sunion(string[] keys...) { 1525 // return new RedisClusterCommand!(Set!(string))(connectionHandler, maxAttempts) { 1526 // override 1527 // Set!(string) execute(Redis connection) { 1528 // return connection.sunion(keys); 1529 // } 1530 // }.run(keys.length, keys); 1531 // } 1532 1533 // override 1534 // Long sunionstore(string dstkey, string[] keys...) { 1535 // string[] wholeKeys = KeyMergeUtil.merge(dstkey, keys); 1536 1537 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 1538 // override 1539 // Long execute(Redis connection) { 1540 // return connection.sunionstore(dstkey, keys); 1541 // } 1542 // }.run(wholeKeys.length, wholeKeys); 1543 // } 1544 1545 // override 1546 // Long zinterstore(string dstkey, string[] sets...) { 1547 // string[] wholeKeys = KeyMergeUtil.merge(dstkey, sets); 1548 1549 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 1550 // override 1551 // Long execute(Redis connection) { 1552 // return connection.zinterstore(dstkey, sets); 1553 // } 1554 // }.run(wholeKeys.length, wholeKeys); 1555 // } 1556 1557 // override 1558 // Long zinterstore(string dstkey, ZParams params, string[] sets...) { 1559 // string[] mergedKeys = KeyMergeUtil.merge(dstkey, sets); 1560 1561 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 1562 // override 1563 // Long execute(Redis connection) { 1564 // return connection.zinterstore(dstkey, params, sets); 1565 // } 1566 // }.run(mergedKeys.length, mergedKeys); 1567 // } 1568 1569 // override 1570 // Long zunionstore(string dstkey, string[] sets...) { 1571 // string[] mergedKeys = KeyMergeUtil.merge(dstkey, sets); 1572 1573 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 1574 // override 1575 // Long execute(Redis connection) { 1576 // return connection.zunionstore(dstkey, sets); 1577 // } 1578 // }.run(mergedKeys.length, mergedKeys); 1579 // } 1580 1581 // override 1582 // Long zunionstore(string dstkey, ZParams params, string[] sets...) { 1583 // string[] mergedKeys = KeyMergeUtil.merge(dstkey, sets); 1584 1585 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 1586 // override 1587 // Long execute(Redis connection) { 1588 // return connection.zunionstore(dstkey, params, sets); 1589 // } 1590 // }.run(mergedKeys.length, mergedKeys); 1591 // } 1592 1593 // override 1594 // string brpoplpush(string source, string destination, int timeout) { 1595 // return new RedisClusterCommand!(string)(connectionHandler, maxAttempts) { 1596 // override 1597 // string execute(Redis connection) { 1598 // return connection.brpoplpush(source, destination, timeout); 1599 // } 1600 // }.run(2, source, destination); 1601 // } 1602 1603 // override 1604 // Long publish(string channel, string message) { 1605 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 1606 // override 1607 // Long execute(Redis connection) { 1608 // return connection.publish(channel, message); 1609 // } 1610 // }.runWithAnyNode(); 1611 // } 1612 1613 // override 1614 // void subscribe(RedisPubSub redisPubSub, string[] channels...) { 1615 // new RedisClusterCommand!(Integer)(connectionHandler, maxAttempts) { 1616 // override 1617 // Integer execute(Redis connection) { 1618 // connection.subscribe(redisPubSub, channels); 1619 // return 0; 1620 // } 1621 // }.runWithAnyNode(); 1622 // } 1623 1624 // override 1625 // void psubscribe(RedisPubSub redisPubSub, string[] patterns...) { 1626 // new RedisClusterCommand!(Integer)(connectionHandler, maxAttempts) { 1627 // override 1628 // Integer execute(Redis connection) { 1629 // connection.psubscribe(redisPubSub, patterns); 1630 // return 0; 1631 // } 1632 // }.runWithAnyNode(); 1633 // } 1634 1635 // override 1636 // Long bitop(BitOP op, string destKey, string[] srcKeys...) { 1637 // string[] mergedKeys = KeyMergeUtil.merge(destKey, srcKeys); 1638 1639 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 1640 // override 1641 // Long execute(Redis connection) { 1642 // return connection.bitop(op, destKey, srcKeys); 1643 // } 1644 // }.run(mergedKeys.length, mergedKeys); 1645 // } 1646 1647 // override 1648 // string pfmerge(string destkey, string[] sourcekeys...) { 1649 // string[] mergedKeys = KeyMergeUtil.merge(destkey, sourcekeys); 1650 1651 // return new RedisClusterCommand!(string)(connectionHandler, maxAttempts) { 1652 // override 1653 // string execute(Redis connection) { 1654 // return connection.pfmerge(destkey, sourcekeys); 1655 // } 1656 // }.run(mergedKeys.length, mergedKeys); 1657 // } 1658 1659 // override 1660 // long pfcount(string[] keys...) { 1661 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 1662 // override 1663 // Long execute(Redis connection) { 1664 // return connection.pfcount(keys); 1665 // } 1666 // }.run(keys.length, keys); 1667 // } 1668 1669 // override 1670 // Object eval(string script, int keyCount, string[] params...) { 1671 // return new RedisClusterCommand!(Object)(connectionHandler, maxAttempts) { 1672 // override 1673 // Object execute(Redis connection) { 1674 // return connection.eval(script, keyCount, params); 1675 // } 1676 // }.run(keyCount, params); 1677 // } 1678 1679 // override 1680 // Object eval(string script, string sampleKey) { 1681 // return new RedisClusterCommand!(Object)(connectionHandler, maxAttempts) { 1682 // override 1683 // Object execute(Redis connection) { 1684 // return connection.eval(script); 1685 // } 1686 // }.run(sampleKey); 1687 // } 1688 1689 // override 1690 // Object eval(string script, List!(string) keys, List!(string) args) { 1691 // return new RedisClusterCommand!(Object)(connectionHandler, maxAttempts) { 1692 // override 1693 // Object execute(Redis connection) { 1694 // return connection.eval(script, keys, args); 1695 // } 1696 // }.run(keys.size(), keys.toArray(new string[keys.size()])); 1697 // } 1698 1699 // override 1700 // Object evalsha(string sha1, int keyCount, string[] params...) { 1701 // return new RedisClusterCommand!(Object)(connectionHandler, maxAttempts) { 1702 // override 1703 // Object execute(Redis connection) { 1704 // return connection.evalsha(sha1, keyCount, params); 1705 // } 1706 // }.run(keyCount, params); 1707 // } 1708 1709 // override 1710 // Object evalsha(string sha1, List!(string) keys, List!(string) args) { 1711 // return new RedisClusterCommand!(Object)(connectionHandler, maxAttempts) { 1712 // override 1713 // Object execute(Redis connection) { 1714 // return connection.evalsha(sha1, keys, args); 1715 // } 1716 // }.run(keys.size(), keys.toArray(new string[keys.size()])); 1717 // } 1718 1719 // override 1720 // Object evalsha(string sha1, string sampleKey) { 1721 // return new RedisClusterCommand!(Object)(connectionHandler, maxAttempts) { 1722 // override 1723 // Object execute(Redis connection) { 1724 // return connection.evalsha(sha1); 1725 // } 1726 // }.run(sampleKey); 1727 // } 1728 1729 // override 1730 // Boolean scriptExists(string sha1, string sampleKey) { 1731 // return new RedisClusterCommand!(Boolean)(connectionHandler, maxAttempts) { 1732 // override 1733 // Boolean execute(Redis connection) { 1734 // return connection.scriptExists(sha1); 1735 // } 1736 // }.run(sampleKey); 1737 // } 1738 1739 // override 1740 // List!(Boolean) scriptExists(string sampleKey, string[] sha1...) { 1741 // return new RedisClusterCommand!(List!(Boolean))(connectionHandler, maxAttempts) { 1742 // override 1743 // List!(Boolean) execute(Redis connection) { 1744 // return connection.scriptExists(sha1); 1745 // } 1746 // }.run(sampleKey); 1747 // } 1748 1749 // override 1750 // string scriptLoad(string script, string sampleKey) { 1751 // return new RedisClusterCommand!(string)(connectionHandler, maxAttempts) { 1752 // override 1753 // string execute(Redis connection) { 1754 // return connection.scriptLoad(script); 1755 // } 1756 // }.run(sampleKey); 1757 // } 1758 1759 // override 1760 // string scriptFlush(string sampleKey) { 1761 // return new RedisClusterCommand!(string)(connectionHandler, maxAttempts) { 1762 // override 1763 // string execute(Redis connection) { 1764 // return connection.scriptFlush(); 1765 // } 1766 // }.run(sampleKey); 1767 // } 1768 1769 // override 1770 // string scriptKill(string sampleKey) { 1771 // return new RedisClusterCommand!(string)(connectionHandler, maxAttempts) { 1772 // override 1773 // string execute(Redis connection) { 1774 // return connection.scriptKill(); 1775 // } 1776 // }.run(sampleKey); 1777 // } 1778 1779 // override 1780 // Long geoadd(string key, double longitude, double latitude, 1781 // string member) { 1782 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 1783 // override 1784 // Long execute(Redis connection) { 1785 // return connection.geoadd(key, longitude, latitude, member); 1786 // } 1787 // }.run(key); 1788 // } 1789 1790 // override 1791 // Long geoadd(string key, Map!(string, GeoCoordinate) memberCoordinateMap) { 1792 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 1793 // override 1794 // Long execute(Redis connection) { 1795 // return connection.geoadd(key, memberCoordinateMap); 1796 // } 1797 // }.run(key); 1798 // } 1799 1800 // override 1801 // Double geodist(string key, string member1, string member2) { 1802 // return new RedisClusterCommand!(Double)(connectionHandler, maxAttempts) { 1803 // override 1804 // Double execute(Redis connection) { 1805 // return connection.geodist(key, member1, member2); 1806 // } 1807 // }.run(key); 1808 // } 1809 1810 // override 1811 // Double geodist(string key, string member1, string member2, 1812 // GeoUnit unit) { 1813 // return new RedisClusterCommand!(Double)(connectionHandler, maxAttempts) { 1814 // override 1815 // Double execute(Redis connection) { 1816 // return connection.geodist(key, member1, member2, unit); 1817 // } 1818 // }.run(key); 1819 // } 1820 1821 // override 1822 // List!(string) geohash(string key, string[] members...) { 1823 // return new RedisClusterCommand!(List!(string))(connectionHandler, maxAttempts) { 1824 // override 1825 // List!(string) execute(Redis connection) { 1826 // return connection.geohash(key, members); 1827 // } 1828 // }.run(key); 1829 // } 1830 1831 // override 1832 // List!(GeoCoordinate) geopos(string key, string[] members...) { 1833 // return new RedisClusterCommand!(List!(GeoCoordinate))(connectionHandler, maxAttempts) { 1834 // override 1835 // List!(GeoCoordinate) execute(Redis connection) { 1836 // return connection.geopos(key, members); 1837 // } 1838 // }.run(key); 1839 // } 1840 1841 // override 1842 // List!(GeoRadiusResponse) georadius(string key, double longitude, 1843 // double latitude, double radius, GeoUnit unit) { 1844 // return new RedisClusterCommand!(List!(GeoRadiusResponse))(connectionHandler, maxAttempts) { 1845 // override 1846 // List!(GeoRadiusResponse) execute(Redis connection) { 1847 // return connection.georadius(key, longitude, latitude, radius, unit); 1848 // } 1849 // }.run(key); 1850 // } 1851 1852 // override 1853 // List!(GeoRadiusResponse) georadiusReadonly(string key, double longitude, 1854 // double latitude, double radius, GeoUnit unit) { 1855 // return new RedisClusterCommand!(List!(GeoRadiusResponse))(connectionHandler, maxAttempts) { 1856 // override 1857 // List!(GeoRadiusResponse) execute(Redis connection) { 1858 // return connection.georadiusReadonly(key, longitude, latitude, radius, unit); 1859 // } 1860 // }.run(key); 1861 // } 1862 1863 // override 1864 // List!(GeoRadiusResponse) georadius(string key, double longitude, 1865 // double latitude, double radius, GeoUnit unit, GeoRadiusParam param) { 1866 // return new RedisClusterCommand!(List!(GeoRadiusResponse))(connectionHandler, maxAttempts) { 1867 // override 1868 // List!(GeoRadiusResponse) execute(Redis connection) { 1869 // return connection.georadius(key, longitude, latitude, radius, unit, param); 1870 // } 1871 // }.run(key); 1872 // } 1873 1874 // override 1875 // List!(GeoRadiusResponse) georadiusReadonly(string key, double longitude, 1876 // double latitude, double radius, GeoUnit unit, GeoRadiusParam param) { 1877 // return new RedisClusterCommand!(List!(GeoRadiusResponse))(connectionHandler, maxAttempts) { 1878 // override 1879 // List!(GeoRadiusResponse) execute(Redis connection) { 1880 // return connection.georadiusReadonly(key, longitude, latitude, radius, unit, param); 1881 // } 1882 // }.run(key); 1883 // } 1884 1885 // override 1886 // List!(GeoRadiusResponse) georadiusByMember(string key, string member, 1887 // double radius, GeoUnit unit) { 1888 // return new RedisClusterCommand!(List!(GeoRadiusResponse))(connectionHandler, maxAttempts) { 1889 // override 1890 // List!(GeoRadiusResponse) execute(Redis connection) { 1891 // return connection.georadiusByMember(key, member, radius, unit); 1892 // } 1893 // }.run(key); 1894 // } 1895 1896 // override 1897 // List!(GeoRadiusResponse) georadiusByMemberReadonly(string key, string member, 1898 // double radius, GeoUnit unit) { 1899 // return new RedisClusterCommand!(List!(GeoRadiusResponse))(connectionHandler, maxAttempts) { 1900 // override 1901 // List!(GeoRadiusResponse) execute(Redis connection) { 1902 // return connection.georadiusByMemberReadonly(key, member, radius, unit); 1903 // } 1904 // }.run(key); 1905 // } 1906 1907 // override 1908 // List!(GeoRadiusResponse) georadiusByMember(string key, string member, 1909 // double radius, GeoUnit unit, GeoRadiusParam param) { 1910 // return new RedisClusterCommand!(List!(GeoRadiusResponse))(connectionHandler, maxAttempts) { 1911 // override 1912 // List!(GeoRadiusResponse) execute(Redis connection) { 1913 // return connection.georadiusByMember(key, member, radius, unit, param); 1914 // } 1915 // }.run(key); 1916 // } 1917 1918 // override 1919 // List!(GeoRadiusResponse) georadiusByMemberReadonly(string key, string member, 1920 // double radius, GeoUnit unit, GeoRadiusParam param) { 1921 // return new RedisClusterCommand!(List!(GeoRadiusResponse))(connectionHandler, maxAttempts) { 1922 // override 1923 // List!(GeoRadiusResponse) execute(Redis connection) { 1924 // return connection.georadiusByMemberReadonly(key, member, radius, unit, param); 1925 // } 1926 // }.run(key); 1927 // } 1928 1929 // override 1930 // List!(Long) bitfield(string key, string[] arguments...) { 1931 // return new RedisClusterCommand!(List!(Long))(connectionHandler, maxAttempts) { 1932 // override 1933 // List!(Long) execute(Redis connection) { 1934 // return connection.bitfield(key, arguments); 1935 // } 1936 // }.run(key); 1937 // } 1938 1939 // override 1940 // Long hstrlen(string key, string field) { 1941 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 1942 // override 1943 // Long execute(Redis connection) { 1944 // return connection.hstrlen(key, field); 1945 // } 1946 // }.run(key); 1947 // } 1948 1949 // override 1950 // StreamEntryID xadd(string key, StreamEntryID id, Map!(string, string) hash) { 1951 // return new RedisClusterCommand!(StreamEntryID)(connectionHandler, maxAttempts) { 1952 // override 1953 // StreamEntryID execute(Redis connection) { 1954 // return connection.xadd(key, id, hash); 1955 // } 1956 // }.run(key); 1957 // } 1958 1959 // override 1960 // StreamEntryID xadd(string key, StreamEntryID id, Map!(string, string) hash, long maxLen, bool approximateLength) { 1961 // return new RedisClusterCommand!(StreamEntryID)(connectionHandler, maxAttempts) { 1962 // override 1963 // StreamEntryID execute(Redis connection) { 1964 // return connection.xadd(key, id, hash, maxLen, approximateLength); 1965 // } 1966 // }.run(key); 1967 // } 1968 1969 // override 1970 // Long xlen(string key) { 1971 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 1972 // override 1973 // Long execute(Redis connection) { 1974 // return connection.xlen(key); 1975 // } 1976 // }.run(key); 1977 // } 1978 1979 // override 1980 // List!(StreamEntry) xrange(string key, StreamEntryID start, StreamEntryID end, int count) { 1981 // return new RedisClusterCommand!(List!(StreamEntry))(connectionHandler, maxAttempts) { 1982 // override 1983 // List!(StreamEntry) execute(Redis connection) { 1984 // return connection.xrange(key, start, end, count); 1985 // } 1986 // }.run(key); 1987 // } 1988 1989 // override 1990 // List!(StreamEntry) xrevrange(string key, StreamEntryID end, StreamEntryID start, int count) { 1991 // return new RedisClusterCommand!(List!(StreamEntry))(connectionHandler, maxAttempts) { 1992 // override 1993 // List!(StreamEntry) execute(Redis connection) { 1994 // return connection.xrevrange(key, end, start, count); 1995 // } 1996 // }.run(key); 1997 // } 1998 1999 // override 2000 // List!(Entry!(string, List!(StreamEntry))) xread(int count, long block, Entry!(string, StreamEntryID) streams...) { 2001 // string[] keys = new string[streams.length]; 2002 // for(int i=0; i<streams.length; ++i) { 2003 // keys[i] = streams[i].getKey(); 2004 // } 2005 2006 // return new RedisClusterCommand!(List!(Entry!(string, List!(StreamEntry))))(connectionHandler, maxAttempts) { 2007 // override 2008 // List!(Entry!(string, List!(StreamEntry))) execute(Redis connection) { 2009 // return connection.xread(count, block, streams); 2010 // } 2011 // }.run(keys.length, keys); 2012 // } 2013 2014 // override 2015 // Long xack(string key, string group, StreamEntryID[] ids...) { 2016 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 2017 // override 2018 // Long execute(Redis connection) { 2019 // return connection.xack(key, group, ids); 2020 // } 2021 // }.run(key); 2022 // } 2023 2024 // override 2025 // string xgroupCreate(string key, string groupname, StreamEntryID id, bool makeStream) { 2026 // return new RedisClusterCommand!(string)(connectionHandler, maxAttempts) { 2027 // override 2028 // string execute(Redis connection) { 2029 // return connection.xgroupCreate(key, groupname, id, makeStream); 2030 // } 2031 // }.run(key); 2032 // } 2033 2034 // override 2035 // string xgroupSetID(string key, string groupname, StreamEntryID id) { 2036 // return new RedisClusterCommand!(string)(connectionHandler, maxAttempts) { 2037 // override 2038 // string execute(Redis connection) { 2039 // return connection.xgroupSetID(key, groupname, id); 2040 // } 2041 // }.run(key); 2042 // } 2043 2044 // override 2045 // Long xgroupDestroy(string key, string groupname) { 2046 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 2047 // override 2048 // Long execute(Redis connection) { 2049 // return connection.xgroupDestroy(key, groupname); 2050 // } 2051 // }.run(key); 2052 // } 2053 2054 // override 2055 // string xgroupDelConsumer(string key, string groupname, string consumername) { 2056 // return new RedisClusterCommand!(string)(connectionHandler, maxAttempts) { 2057 // override 2058 // string execute(Redis connection) { 2059 // return connection.xgroupDelConsumer(key, groupname, consumername); 2060 // } 2061 // }.run(key); 2062 // } 2063 2064 // override 2065 // List!(Entry!(string, List!(StreamEntry))) xreadGroup(string groupname, string consumer, int count, long block, 2066 // bool noAck, Entry!(string, StreamEntryID) streams...) { 2067 2068 // string[] keys = new string[streams.length]; 2069 // for(int i=0; i<streams.length; ++i) { 2070 // keys[i] = streams[i].getKey(); 2071 // } 2072 2073 // return new RedisClusterCommand!(List!(Entry!(string, List!(StreamEntry))))(connectionHandler, maxAttempts) { 2074 // override 2075 // List!(Entry!(string, List!(StreamEntry))) execute(Redis connection) { 2076 // return connection.xreadGroup(groupname, consumer, count, block, noAck, streams); 2077 // } 2078 // }.run(keys.length, keys); 2079 // } 2080 2081 // override 2082 // List!(StreamPendingEntry) xpending(string key, string groupname, StreamEntryID start, StreamEntryID end, int count, 2083 // string consumername) { 2084 // return new RedisClusterCommand!(List!(StreamPendingEntry))(connectionHandler, maxAttempts) { 2085 // override 2086 // List!(StreamPendingEntry) execute(Redis connection) { 2087 // return connection.xpending(key, groupname, start, end, count, consumername); 2088 // } 2089 // }.run(key); 2090 // } 2091 2092 // override 2093 // Long xdel(string key, StreamEntryID[] ids...) { 2094 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 2095 // override 2096 // Long execute(Redis connection) { 2097 // return connection.xdel(key, ids); 2098 // } 2099 // }.run(key); 2100 // } 2101 2102 // override 2103 // Long xtrim( string key, long maxLen, bool approximateLength) { 2104 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 2105 // override 2106 // Long execute(Redis connection) { 2107 // return connection.xtrim(key, maxLen, approximateLength); 2108 // } 2109 // }.run(key); 2110 // } 2111 2112 // override 2113 // List!(StreamEntry) xclaim(string key, string group, string consumername, long minIdleTime, long newIdleTime, 2114 // int retries, bool force, StreamEntryID[] ids...) { 2115 // return new RedisClusterCommand!(List!(StreamEntry))(connectionHandler, maxAttempts) { 2116 // override 2117 // List!(StreamEntry) execute(Redis connection) { 2118 // return connection.xclaim(key, group, consumername, minIdleTime, newIdleTime, retries, force, ids); 2119 // } 2120 // }.run(key); 2121 // } 2122 2123 // Long waitReplicas(string key, int replicas, long timeout) { 2124 // return new RedisClusterCommand!(Long)(connectionHandler, maxAttempts) { 2125 // override 2126 // Long execute(Redis connection) { 2127 // return connection.waitReplicas(replicas, timeout); 2128 // } 2129 // }.run(key); 2130 // } 2131 2132 // override 2133 // Object sendCommand(string sampleKey, ProtocolCommand cmd, string[] args...) { 2134 // return new RedisClusterCommand!(Object)(connectionHandler, maxAttempts) { 2135 // override 2136 // Object execute(Redis connection){ 2137 // return connection.sendCommand(cmd, args); 2138 // } 2139 // }.run(sampleKey); 2140 // } 2141 2142 2143 }