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