trait RedisKeyedApi extends KeyedKeysApi with StringsApi with KeyedClusterApi with GeoApi with KeyedScriptingApi with HashesApi with SortedSetsApi with ListsApi with SetsApi with HyperLogLogApi with StreamsApi
- Alphabetic
- By Inheritance
- RedisKeyedApi
- StreamsApi
- HyperLogLogApi
- SetsApi
- ListsApi
- SortedSetsApi
- HashesApi
- KeyedScriptingApi
- GeoApi
- KeyedClusterApi
- StringsApi
- KeyedKeysApi
- ApiSubset
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Type Members
-
type
Field = RedisSerialization.Field
- Definition Classes
- ApiSubset
-
type
Key = RedisSerialization.Key
- Definition Classes
- ApiSubset
-
type
Record = RedisSerialization.Record
- Definition Classes
- ApiSubset
-
abstract
type
Result[A]
The type constructor into which a result of each command is wrapped.
-
type
Value = RedisSerialization.Value
- Definition Classes
- ApiSubset
-
type
XEntry = commands.XEntry[Record]
- Definition Classes
- StreamsApi
Abstract Value Members
-
abstract
def
execute[A](command: RedisCommand[A]): Result[A]
- Definition Classes
- ApiSubset
-
abstract
val
serialization: RedisSerialization
- Definition Classes
- ApiSubset
Concrete Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
append(key: Key, value: Value): Result[Int]
Executes APPEND
Executes APPEND
- Definition Classes
- StringsApi
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
bitcount(key: Key, range: commons.OptArg[(Int, Int)] = OptArg.Empty): Result[Long]
Executes BITCOUNT
Executes BITCOUNT
- Definition Classes
- StringsApi
-
def
bitfield(key: Key, ops: Iterable[BitFieldOp]): Result[Seq[commons.Opt[Long]]]
Executes BITFIELD
Executes BITFIELD
- Definition Classes
- StringsApi
-
def
bitfield(key: Key, op: BitFieldOp, ops: BitFieldOp*): Result[Seq[commons.Opt[Long]]]
Executes BITFIELD
Executes BITFIELD
- Definition Classes
- StringsApi
-
def
bitfield(key: Key, op: BitFieldOp): Result[commons.Opt[Long]]
Executes BITFIELD
Executes BITFIELD
- Definition Classes
- StringsApi
-
def
bitop(multiOperation: MultiBitOp, destkey: Key, keys: Key*): Result[Int]
Executes BITOP
Executes BITOP
- Definition Classes
- StringsApi
-
def
bitopNot(destkey: Key, key: Key): Result[Int]
Executes BITOP
Executes BITOP
- Definition Classes
- StringsApi
-
def
bitpos(key: Key, bit: Boolean, start: Int, end: Int): Result[Long]
Executes BITPOS
Executes BITPOS
- Definition Classes
- StringsApi
-
def
bitpos(key: Key, bit: Boolean, start: Int): Result[Long]
Executes BITPOS
Executes BITPOS
- Definition Classes
- StringsApi
-
def
bitpos(key: Key, bit: Boolean): Result[Long]
Executes BITPOS
Executes BITPOS
- Definition Classes
- StringsApi
-
def
blpop(keys: Iterable[Key], timeout: Int): Result[commons.Opt[(Key, Value)]]
Executes BLPOP
-
def
blpop(key: Key, timeout: Int): Result[commons.Opt[Value]]
Executes BLPOP
-
def
brpop(keys: Iterable[Key], timeout: Int): Result[commons.Opt[(Key, Value)]]
Executes BRPOP
-
def
brpop(key: Key, timeout: Int): Result[commons.Opt[Value]]
Executes BRPOP
-
def
brpoplpush(source: Key, destination: Key, timeout: Int): Result[commons.Opt[Value]]
Executes BRPOPLPUSH
Executes BRPOPLPUSH
- Definition Classes
- ListsApi
-
def
bzpopmax(keys: Iterable[Key], timeout: Int): Result[commons.Opt[(Key, Value, Double)]]
Executes BZPOPMAX
Executes BZPOPMAX
- Definition Classes
- SortedSetsApi
-
def
bzpopmax(key: Key, timeout: Int): Result[commons.Opt[(Value, Double)]]
Executes BZPOPMAX
Executes BZPOPMAX
- Definition Classes
- SortedSetsApi
-
def
bzpopmin(keys: Iterable[Key], timeout: Int): Result[commons.Opt[(Key, Value, Double)]]
Executes BZPOPMIN
Executes BZPOPMIN
- Definition Classes
- SortedSetsApi
-
def
bzpopmin(key: Key, timeout: Int): Result[commons.Opt[(Value, Double)]]
Executes BZPOPMIN
Executes BZPOPMIN
- Definition Classes
- SortedSetsApi
-
def
clone(): AnyRef
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @native() @throws( ... )
-
def
clusterKeyslot(key: Key): Result[Int]
Executes CLUSTER KEYSLOT
Executes CLUSTER KEYSLOT
- Definition Classes
- KeyedClusterApi
-
def
decr(key: Key): Result[Long]
Executes DECR
Executes DECR
- Definition Classes
- StringsApi
-
def
decrby(key: Key, decrement: Long): Result[Long]
Executes DECRBY
Executes DECRBY
- Definition Classes
- StringsApi
-
def
del(keys: Iterable[Key]): Result[Int]
Executes DEL or simply returns 0 if
keys
is empty, without sending the command to RedisExecutes DEL or simply returns 0 if
keys
is empty, without sending the command to Redis- Definition Classes
- KeyedKeysApi
-
def
del(key: Key, keys: Key*): Result[Int]
Executes DEL
Executes DEL
- Definition Classes
- KeyedKeysApi
-
def
del(key: Key): Result[Boolean]
Executes DEL
Executes DEL
- Definition Classes
- KeyedKeysApi
-
def
dump(key: Key): Result[commons.Opt[Dumped]]
Executes DUMP
Executes DUMP
- Definition Classes
- KeyedKeysApi
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
eval[T](source: String, keys: Seq[Key], args: Seq[Value])(decoder: ReplyDecoder[T]): Result[T]
Executes EVAL
Executes EVAL
- Definition Classes
- KeyedScriptingApi
-
def
eval[T](script: RedisScript[T], keys: Seq[Key], args: Seq[Value]): Result[T]
Executes EVAL
Executes EVAL
- Definition Classes
- KeyedScriptingApi
-
def
evalsha[T](sha1: Sha1, keys: Seq[Key], args: Seq[Value])(decoder: ReplyDecoder[T]): Result[T]
Executes EVALSHA
Executes EVALSHA
- Definition Classes
- KeyedScriptingApi
-
def
evalsha[T](script: RedisScript[T], keys: Seq[Key], args: Seq[Value]): Result[T]
Executes EVALSHA
Executes EVALSHA
- Definition Classes
- KeyedScriptingApi
-
def
exists(keys: Iterable[Key]): Result[Int]
Executes EXISTS or simply returns 0 when
keys
is empty, without sending the command to RedisExecutes EXISTS or simply returns 0 when
keys
is empty, without sending the command to Redis- Definition Classes
- KeyedKeysApi
-
def
exists(key: Key, keys: Key*): Result[Int]
Executes EXISTS
Executes EXISTS
- Definition Classes
- KeyedKeysApi
-
def
exists(key: Key): Result[Boolean]
Executes EXISTS
Executes EXISTS
- Definition Classes
- KeyedKeysApi
-
def
expire(key: Key, seconds: Long): Result[Boolean]
Executes EXPIRE
Executes EXPIRE
- Definition Classes
- KeyedKeysApi
-
def
expireat(key: Key, timestamp: Long): Result[Boolean]
Executes EXPIREAT
Executes EXPIREAT
- Definition Classes
- KeyedKeysApi
-
implicit final
def
fieldCodec: RedisDataCodec[Field]
- Attributes
- protected
- Definition Classes
- ApiSubset
-
def
finalize(): Unit
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
def
geoadd(key: Key, items: Iterable[(Value, GeoPoint)]): Result[Int]
Executes GEOADD or simply returns 0 when
items
is empty, without sending the command Redis -
def
geoadd(key: Key, item: (Value, GeoPoint), items: (Value, GeoPoint)*): Result[Int]
Executes GEOADD
-
def
geoadd(key: Key, member: Value, point: GeoPoint): Result[Boolean]
Executes GEOADD
-
def
geodist(key: Key, member1: Value, member2: Value, unit: GeoUnit = GeoUnit.M): Result[commons.Opt[Double]]
Executes GEODIST
-
def
geohash(key: Key, members: Iterable[Value]): Result[Seq[commons.Opt[GeoHash]]]
Executes GEOHASH NOTE:
members
CAN be empty (Redis accepts it) -
def
geohash(key: Key, members: Value*): Result[Seq[commons.Opt[GeoHash]]]
Executes GEOHASH
-
def
geopos(key: Key, members: Iterable[Value]): Result[Seq[commons.Opt[GeoPoint]]]
Executes GEOPOS NOTE:
members
CAN be empty (Redis accepts it) -
def
geopos(key: Key, members: Value*): Result[Seq[commons.Opt[GeoPoint]]]
Executes GEOPOS
-
def
georadius[A <: GeoradiusAttrs](key: Key, point: GeoPoint, radius: Double, unit: GeoUnit, attributes: A = GeoradiusAttrs.None, count: commons.OptArg[Long] = OptArg.Empty, sortOrder: commons.OptArg[SortOrder] = OptArg.Empty, readOnly: Boolean = false): Result[Seq[commands.GeoApi.georadius.A.Attributed[Value]]]
Executes GEORADIUS
-
def
georadiusStore(key: Key, point: GeoPoint, radius: Double, unit: GeoUnit, storeKey: Key, storeDist: Boolean = false, count: commons.OptArg[Long] = OptArg.Empty, sortOrder: commons.OptArg[SortOrder] = OptArg.Empty): Result[commons.Opt[Long]]
Executes GEORADIUS
-
def
georadiusbymember[A <: GeoradiusAttrs](key: Key, member: Value, radius: Double, unit: GeoUnit, attributes: A = GeoradiusAttrs.None, count: commons.OptArg[Long] = OptArg.Empty, sortOrder: commons.OptArg[SortOrder] = OptArg.Empty, readOnly: Boolean = false): Result[Seq[commands.GeoApi.georadiusbymember.A.Attributed[Value]]]
Executes GEORADIUSBYMEMBER
Executes GEORADIUSBYMEMBER
- Definition Classes
- GeoApi
-
def
georadiusbymemberStore(key: Key, member: Value, radius: Double, unit: GeoUnit, storeKey: Key, storeDist: Boolean = false, count: commons.OptArg[Long] = OptArg.Empty, sortOrder: commons.OptArg[SortOrder] = OptArg.Empty): Result[commons.Opt[Long]]
Executes GEORADIUSBYMEMBER
Executes GEORADIUSBYMEMBER
- Definition Classes
- GeoApi
-
def
get(key: Key): Result[commons.Opt[Value]]
Executes GET
Executes GET
- Definition Classes
- StringsApi
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
getbit(key: Key, offset: Int): Result[Boolean]
Executes GETBIT
Executes GETBIT
- Definition Classes
- StringsApi
-
def
getrange(key: Key, start: Int = 0, end: Int = -1): Result[Value]
Executes GETRANGE
Executes GETRANGE
- Definition Classes
- StringsApi
-
def
getset(key: Key, value: Value): Result[commons.Opt[Value]]
Executes GETSET
Executes GETSET
- Definition Classes
- StringsApi
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
hdel(key: Key, fields: Iterable[Field]): Result[Int]
Executes HDEL or simply returns 0 when
fields
is empty, without sending the command to Redis -
def
hdel(key: Key, field: Field, fields: Field*): Result[Int]
Executes HDEL
-
def
hdel(key: Key, field: Field): Result[Boolean]
Executes HDEL
-
implicit
def
headOps[T](head: T): HeadOps[T]
- Attributes
- protected
- Definition Classes
- ApiSubset
-
def
hexists(key: Key, field: Field): Result[Boolean]
Executes HEXISTS
-
def
hget(key: Key, field: Field): Result[commons.Opt[Value]]
Executes HGET
-
def
hgetall(key: Key): Result[commons.BMap[Field, Value]]
Executes HGETALL
-
def
hgetallRecord(key: Key): Result[commons.Opt[Record]]
Executes HGETALL
-
def
hincrby(key: Key, field: Field, increment: Long): Result[Long]
Executes HINCRBY
-
def
hincrbyfloat(key: Key, field: Field, increment: Double): Result[Double]
Executes HINCRBYFLOAT
Executes HINCRBYFLOAT
- Definition Classes
- HashesApi
-
def
hkeys(key: Key): Result[commons.BSet[Field]]
Executes HKEYS
-
def
hlen(key: Key): Result[Long]
Executes HLEN
-
def
hmget(key: Key, fields: Iterable[Field]): Result[Seq[commons.Opt[Value]]]
Executes HMGET or simply returns empty
Seq
whenfields
is empty, without sending the command to Redis -
def
hmget(key: Key, field: Field, fields: Field*): Result[Seq[commons.Opt[Value]]]
Executes HMGET
-
def
hmset(key: Key, fieldValues: Iterable[(Field, Value)]): Result[Unit]
Executes HMSET or does nothing when
fieldValues
is empty, without sending the command to Redis -
def
hmset(key: Key, fieldValue: (Field, Value), fieldValues: (Field, Value)*): Result[Unit]
Executes HMSET
-
def
hmsetRecord(key: Key, data: Record): Result[Unit]
Executes HMSET or does nothing when
data
is empty, without sending the command to Redis -
def
hscan(key: Key, cursor: Cursor, matchPattern: commons.OptArg[Field] = OptArg.Empty, count: commons.OptArg[Int] = OptArg.Empty): Result[(Cursor, Seq[(Field, Value)])]
Executes HSCAN
-
def
hset(key: Key, fieldValues: Iterable[(Field, Value)]): Result[Int]
Executes HSET or does nothing when
fieldValues
is empty, without sending the command to Redis -
def
hset(key: Key, fieldValue: (Field, Value), fieldValues: (Field, Value)*): Result[Int]
Executes HSET
-
def
hset(key: Key, field: Field, value: Value): Result[Boolean]
Executes HSET
-
def
hsetRecord(key: Key, data: Record): Result[Int]
Executes HSET or does nothing when
data
is empty, without sending the command to Redis -
def
hsetnx(key: Key, field: Field, value: Value): Result[Boolean]
Executes HSETNX
-
def
hstrlen(key: Key, field: Field): Result[Int]
Executes HSTRLEN
-
def
hvals(key: Key): Result[Iterable[Value]]
Executes HVALS
-
def
incr(key: Key): Result[Long]
Executes INCR
Executes INCR
- Definition Classes
- StringsApi
-
def
incrby(key: Key, increment: Long): Result[Long]
Executes INCRBY
Executes INCRBY
- Definition Classes
- StringsApi
-
def
incrbyfloat(key: Key, increment: Double): Result[Double]
Executes INCRBYFLOAT
Executes INCRBYFLOAT
- Definition Classes
- StringsApi
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
implicit
def
iterableTailOps[T](tail: Iterable[T]): IterableTailOps[T]
- Attributes
- protected
- Definition Classes
- ApiSubset
-
implicit
def
iteratorTailOps[T](tail: Iterator[T]): IteratorTailOps[T]
- Attributes
- protected
- Definition Classes
- ApiSubset
-
implicit final
def
keyCodec: RedisDataCodec[Key]
- Attributes
- protected
- Definition Classes
- ApiSubset
-
def
keySlot(key: Key): Int
- Definition Classes
- KeyedClusterApi
-
def
lindex(key: Key, index: Long): Result[commons.Opt[Value]]
Executes LINDEX
-
def
linsert(key: Key, pivot: Value, value: Value, before: Boolean = false): Result[commons.Opt[Long]]
Executes LINSERT
-
def
llen(key: Key): Result[Long]
Executes LLEN
-
def
lpop(key: Key): Result[commons.Opt[Value]]
Executes LPOP
-
def
lpush(key: Key, values: Iterable[Value]): Result[Long]
Executes LPUSH NOTE:
values
MUST NOT be empty - consider using lpushOrLlen in such case.Executes LPUSH NOTE:
values
MUST NOT be empty - consider using lpushOrLlen in such case.- Definition Classes
- ListsApi
-
def
lpush(key: Key, value: Value, values: Value*): Result[Long]
Executes LPUSH
- def lpushOrLlen(key: Key, values: Iterable[Value]): Result[Long]
-
def
lpushx(key: Key, values: Iterable[Value]): Result[Long]
Executes LPUSHX
-
def
lpushx(key: Key, value: Value, values: Value*): Result[Long]
Executes LPUSHX
- def lpushxOrLlen(key: Key, values: Iterable[Value]): Result[Long]
-
def
lrange(key: Key, start: Long = 0, stop: Long = -1): Result[Seq[Value]]
Executes LRANGE
-
def
lrem(key: Key, value: Value, count: RemCount = RemCount.All): Result[Long]
Executes LREM
-
def
lset(key: Key, index: Long, value: Value): Result[Unit]
Executes LSET
-
def
ltrim(key: Key, start: Long = 0, stop: Long = -1): Result[Unit]
Executes LTRIM
-
def
memoryUsage(key: Key, samples: commons.OptArg[Long] = OptArg.Empty): Result[commons.Opt[Long]]
- Definition Classes
- KeyedKeysApi
-
def
mget(keys: Iterable[Key]): Result[Seq[commons.Opt[Value]]]
Executes MGET or simply returns empty
Seq
whenkeys
is empty, without sending the command to RedisExecutes MGET or simply returns empty
Seq
whenkeys
is empty, without sending the command to Redis- Definition Classes
- StringsApi
-
def
mget(key: Key, keys: Key*): Result[Seq[commons.Opt[Value]]]
Executes MGET
Executes MGET
- Definition Classes
- StringsApi
-
def
migrate(keys: Iterable[Key], address: NodeAddress, destinationDb: Int, timeout: Long, copy: Boolean = false, replace: Boolean = false): Result[Boolean]
Executes MIGRATE or simply returns
true
whenkeys
is empty, without sending the command to RedisExecutes MIGRATE or simply returns
true
whenkeys
is empty, without sending the command to Redis- Definition Classes
- KeyedKeysApi
-
def
mset(keyValues: Iterable[(Key, Value)]): Result[Unit]
Executes MSET or does nothing when
keyValues
is empty, without sending the command to RedisExecutes MSET or does nothing when
keyValues
is empty, without sending the command to Redis- Definition Classes
- StringsApi
-
def
mset(keyValue: (Key, Value), keyValues: (Key, Value)*): Result[Unit]
Executes MSET
Executes MSET
- Definition Classes
- StringsApi
-
def
msetnx(keyValues: Iterable[(Key, Value)]): Result[Boolean]
Executes MSETNX or simply returns
true
whenkeyValues
is empty, without sending the command to RedisExecutes MSETNX or simply returns
true
whenkeyValues
is empty, without sending the command to Redis- Definition Classes
- StringsApi
-
def
msetnx(keyValue: (Key, Value), keyValues: (Key, Value)*): Result[Boolean]
Executes MSETNX
Executes MSETNX
- Definition Classes
- StringsApi
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
def
objectEncoding(key: Key): Result[commons.Opt[Encoding]]
Executes OBJECT
Executes OBJECT
- Definition Classes
- KeyedKeysApi
-
def
objectIdletime(key: Key): Result[commons.Opt[Long]]
Executes OBJECT
Executes OBJECT
- Definition Classes
- KeyedKeysApi
-
def
objectRefcount(key: Key): Result[commons.Opt[Long]]
Executes OBJECT
Executes OBJECT
- Definition Classes
- KeyedKeysApi
-
def
persist(key: Key): Result[Boolean]
Executes PERSIST
Executes PERSIST
- Definition Classes
- KeyedKeysApi
-
def
pexpire(key: Key, milliseconds: Long): Result[Boolean]
Executes PEXPIRE
Executes PEXPIRE
- Definition Classes
- KeyedKeysApi
-
def
pexpireat(key: Key, millisecondsTimestamp: Long): Result[Boolean]
Executes PEXPIREAT
Executes PEXPIREAT
- Definition Classes
- KeyedKeysApi
-
def
pfadd(key: Key, elements: Iterable[Value]): Result[Boolean]
Executes PFADD NOTE:
elements
CAN be empty, Redis accepts itExecutes PFADD NOTE:
elements
CAN be empty, Redis accepts it- Definition Classes
- HyperLogLogApi
-
def
pfadd(key: Key, elements: Value*): Result[Boolean]
Executes PFADD
Executes PFADD
- Definition Classes
- HyperLogLogApi
-
def
pfcount(keys: Iterable[Key]): Result[Long]
Executes PFCOUNT or simply returns 0 when
keys
is empty, without sending the command to RedisExecutes PFCOUNT or simply returns 0 when
keys
is empty, without sending the command to Redis- Definition Classes
- HyperLogLogApi
-
def
pfcount(key: Key, keys: Key*): Result[Long]
Executes PFCOUNT
Executes PFCOUNT
- Definition Classes
- HyperLogLogApi
-
def
pfmerge(destkey: Key, sourcekeys: Iterable[Key]): Result[Unit]
Executes PFMERGE.
Executes PFMERGE. NOTE:
sourcekeys
CAN be empty, Redis accepts it- Definition Classes
- HyperLogLogApi
-
def
pfmerge(destkey: Key, sourcekeys: Key*): Result[Unit]
Executes PFMERGE
Executes PFMERGE
- Definition Classes
- HyperLogLogApi
-
def
psetex(key: Key, milliseconds: Long, value: Value): Result[Unit]
Executes PSETEX
Executes PSETEX
- Definition Classes
- StringsApi
-
def
pttl(key: Key): Result[commons.Opt[commons.Opt[Long]]]
Executes PTTL
Executes PTTL
- Definition Classes
- KeyedKeysApi
-
implicit final
def
recordCodec: RedisRecordCodec[Record]
- Attributes
- protected
- Definition Classes
- ApiSubset
-
def
rename(key: Key, newkey: Key): Result[Unit]
Executes RENAME
Executes RENAME
- Definition Classes
- KeyedKeysApi
-
def
renamenx(key: Key, newkey: Key): Result[Boolean]
Executes RENAMENX
Executes RENAMENX
- Definition Classes
- KeyedKeysApi
-
def
restore(key: Key, ttl: Long, dumpedValue: Dumped, replace: Boolean = false): Result[Unit]
Executes RESTORE
Executes RESTORE
- Definition Classes
- KeyedKeysApi
-
def
rpop(key: Key): Result[commons.Opt[Value]]
Executes RPOP
-
def
rpoplpush(source: Key, destination: Key): Result[commons.Opt[Value]]
Executes RPOPLPUSH
-
def
rpush(key: Key, values: Iterable[Value]): Result[Long]
Executes RPUSH NOTE:
values
MUST NOT be empty - consider using rpushOrLlen in such case.Executes RPUSH NOTE:
values
MUST NOT be empty - consider using rpushOrLlen in such case.- Definition Classes
- ListsApi
-
def
rpush(key: Key, value: Value, values: Value*): Result[Long]
Executes RPUSH
- def rpushOrLlen(key: Key, values: Iterable[Value]): Result[Long]
-
def
rpushx(key: Key, values: Iterable[Value]): Result[Long]
Executes RPUSHX
-
def
rpushx(key: Key, value: Value, values: Value*): Result[Long]
Executes RPUSHX
- def rpushxOrLlen(key: Key, values: Iterable[Value]): Result[Long]
-
def
sadd(key: Key, members: Iterable[Value]): Result[Int]
Executes SADD or simply returns 0 when
members
is empty -
def
sadd(key: Key, member: Value, members: Value*): Result[Int]
Executes SADD
-
def
sadd(key: Key, member: Value): Result[Boolean]
Executes SADD
-
def
scard(key: Key): Result[Long]
Executes SCARD
-
def
sdiff(source: Key, keys: Iterable[Key]): Result[commons.BSet[Value]]
Executes SDIFF
-
def
sdiff(source: Key, keys: Key*): Result[commons.BSet[Value]]
Executes SDIFF
-
def
sdiffstore(destination: Key, source: Key, keys: Iterable[Key]): Result[Long]
Executes SDIFFSTORE
Executes SDIFFSTORE
- Definition Classes
- SetsApi
-
def
sdiffstore(destination: Key, source: Key, keys: Key*): Result[Long]
Executes SDIFFSTORE
Executes SDIFFSTORE
- Definition Classes
- SetsApi
-
def
set(key: Key, value: Value, expiration: commons.OptArg[Expiration] = OptArg.Empty, existence: commons.OptArg[Boolean] = OptArg.Empty): Result[Boolean]
Executes SET
Executes SET
- Definition Classes
- StringsApi
-
def
setbit(key: Key, offset: Long, value: Boolean): Result[Boolean]
Executes SETBIT
Executes SETBIT
- Definition Classes
- StringsApi
-
def
setex(key: Key, seconds: Long, value: Value): Result[Unit]
Executes SETEX
Executes SETEX
- Definition Classes
- StringsApi
-
def
setnx(key: Key, value: Value): Result[Boolean]
Executes SETNX
Executes SETNX
- Definition Classes
- StringsApi
-
def
setrange(key: Key, offset: Int, value: Value): Result[Int]
Executes SETRANGE
Executes SETRANGE
- Definition Classes
- StringsApi
-
def
sinter(keys: Iterable[Key]): Result[commons.BSet[Value]]
Executes SINTER NOTE:
keys
MUST NOT be empty -
def
sinter(key: Key, keys: Key*): Result[commons.BSet[Value]]
Executes SINTER
-
def
sinterstore(destination: Key, keys: Iterable[Key]): Result[Long]
Executes SINTERSTORE NOTE:
keys
MUST NOT be emptyExecutes SINTERSTORE NOTE:
keys
MUST NOT be empty- Definition Classes
- SetsApi
-
def
sinterstore(destination: Key, key: Key, keys: Key*): Result[Long]
Executes SINTERSTORE
Executes SINTERSTORE
- Definition Classes
- SetsApi
-
def
sismember(key: Key, member: Value): Result[Boolean]
Executes SISMEMBER
-
def
smembers(key: Key): Result[commons.BSet[Value]]
Executes SMEMBERS
-
def
smove(source: Key, destination: Key, member: Value): Result[Boolean]
Executes SMOVE
-
def
sort(key: Key, by: commons.OptArg[SortPattern[Key, Field]] = OptArg.Empty, limit: commons.OptArg[SortLimit] = OptArg.Empty, sortOrder: commons.OptArg[SortOrder] = OptArg.Empty, alpha: Boolean = false): Result[Seq[Value]]
Executes SORT
Executes SORT
- Definition Classes
- KeyedKeysApi
-
def
sortGet(key: Key, gets: Seq[SortPattern[Key, Field]], by: commons.OptArg[SortPattern[Key, Field]] = OptArg.Empty, limit: commons.OptArg[SortLimit] = OptArg.Empty, sortOrder: commons.OptArg[SortOrder] = OptArg.Empty, alpha: Boolean = false): Result[Seq[Seq[commons.Opt[Value]]]]
Executes SORT
Executes SORT
- Definition Classes
- KeyedKeysApi
-
def
sortStore(key: Key, destination: Key, by: commons.OptArg[SortPattern[Key, Field]] = OptArg.Empty, limit: commons.OptArg[SortLimit] = OptArg.Empty, gets: Seq[SortPattern[Key, Field]] = Nil, sortOrder: commons.OptArg[SortOrder] = OptArg.Empty, alpha: Boolean = false): Result[Long]
Executes SORT
Executes SORT
- Definition Classes
- KeyedKeysApi
-
def
spop(key: Key, count: Int): Result[commons.BSet[Value]]
Executes SPOP
-
def
spop(key: Key): Result[commons.Opt[Value]]
Executes SPOP
-
def
srandmember(key: Key, count: Int): Result[Seq[Value]]
Executes SRANDMEMBER
Executes SRANDMEMBER
- Definition Classes
- SetsApi
-
def
srandmember(key: Key): Result[commons.Opt[Value]]
Executes SRANDMEMBER
Executes SRANDMEMBER
- Definition Classes
- SetsApi
-
def
srandmemberDistinct(key: Key, count: Int): Result[commons.BSet[Value]]
Executes SRANDMEMBER
Executes SRANDMEMBER
- Definition Classes
- SetsApi
-
def
srem(key: Key, members: Iterable[Value]): Result[Int]
Executes SREM or simply returns 0 when
members
is empty -
def
srem(key: Key, member: Value, members: Value*): Result[Int]
Executes SREM
-
def
srem(key: Key, member: Value): Result[Boolean]
Executes SREM
-
def
sscan(key: Key, cursor: Cursor, matchPattern: commons.OptArg[Value] = OptArg.Empty, count: commons.OptArg[Int] = OptArg.Empty): Result[(Cursor, Seq[Value])]
Executes SSCAN
-
def
strlen(key: Key): Result[Int]
Executes STRLEN
Executes STRLEN
- Definition Classes
- StringsApi
-
def
sunion(keys: Iterable[Key]): Result[commons.BSet[Value]]
Executes SUNION or simply returns empty set when
keys
is empty -
def
sunion(key: Key, keys: Key*): Result[commons.BSet[Value]]
Executes SUNION
-
def
sunionstore(destination: Key, keys: Iterable[Key]): Result[Long]
Executes SUNIONSTORE NOTE: unlike in
SUNION
keys
MUST NOT be empty becauseSUNIONSTORE
overwrites destination key.Executes SUNIONSTORE NOTE: unlike in
SUNION
keys
MUST NOT be empty becauseSUNIONSTORE
overwrites destination key. An operation equivalent to invokingSUNIONSTORE
with onlydestination
and nokeys
would beDEL destination
- Definition Classes
- SetsApi
-
def
sunionstore(destination: Key, key: Key, keys: Key*): Result[Long]
Executes SUNIONSTORE
Executes SUNIONSTORE
- Definition Classes
- SetsApi
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
toString(): String
- Definition Classes
- AnyRef → Any
-
def
touch(keys: Iterable[Key]): Result[Int]
Executes TOUCH or simply returns 0 when
keys
is empty, without sending the command to RedisExecutes TOUCH or simply returns 0 when
keys
is empty, without sending the command to Redis- Definition Classes
- KeyedKeysApi
-
def
touch(key: Key, keys: Key*): Result[Int]
Executes TOUCH
Executes TOUCH
- Definition Classes
- KeyedKeysApi
-
def
touch(key: Key): Result[Boolean]
Executes TOUCH
Executes TOUCH
- Definition Classes
- KeyedKeysApi
-
def
ttl(key: Key): Result[commons.Opt[commons.Opt[Long]]]
Executes TTL
Executes TTL
- Definition Classes
- KeyedKeysApi
-
def
type(key: Key): Result[RedisType]
Executes TYPE
Executes TYPE
- Definition Classes
- KeyedKeysApi
-
def
unlink(keys: Iterable[Key]): Result[Int]
Executes UNLINK or simply returns 0 when
keys
is empty, without sending the command to RedisExecutes UNLINK or simply returns 0 when
keys
is empty, without sending the command to Redis- Definition Classes
- KeyedKeysApi
-
def
unlink(key: Key, keys: Key*): Result[Int]
Executes UNLINK
Executes UNLINK
- Definition Classes
- KeyedKeysApi
-
def
unlink(key: Key): Result[Boolean]
Executes UNLINK
Executes UNLINK
- Definition Classes
- KeyedKeysApi
-
implicit final
def
valueCodec: RedisDataCodec[Value]
- Attributes
- protected
- Definition Classes
- ApiSubset
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @throws( ... )
-
def
xack(key: Key, group: XGroup, ids: Iterable[XEntryId]): Result[Int]
Executes XACK
Executes XACK
- Definition Classes
- StreamsApi
-
def
xack(key: Key, group: XGroup, id: XEntryId, ids: XEntryId*): Result[Int]
Executes XACK
Executes XACK
- Definition Classes
- StreamsApi
-
def
xack(key: Key, group: XGroup, id: XEntryId): Result[Boolean]
Executes XACK
Executes XACK
- Definition Classes
- StreamsApi
-
def
xadd(key: Key, data: Record, id: commons.OptArg[XEntryId] = OptArg.Empty, maxlen: commons.OptArg[XMaxlen] = OptArg.Empty): Result[XEntryId]
Executes XADD
Executes XADD
- Definition Classes
- StreamsApi
-
def
xaddEntry(key: Key, entry: XEntry, maxlen: commons.OptArg[XMaxlen] = OptArg.Empty): Result[XEntryId]
Executes XADD
Executes XADD
- Definition Classes
- StreamsApi
-
def
xclaim(key: Key, group: XGroup, consumer: XConsumer, minIdleMillis: Long, ids: Iterable[XEntryId], idleMillis: commons.OptArg[Long] = OptArg.Empty, msUnixTime: commons.OptArg[Long] = OptArg.Empty, retrycount: commons.OptArg[Int] = OptArg.Empty, force: Boolean = false): Result[Seq[XEntry]]
Executes XCLAIM
Executes XCLAIM
- Definition Classes
- StreamsApi
-
def
xclaimJustid(key: Key, group: XGroup, consumer: XConsumer, minIdleMillis: Long, ids: Iterable[XEntryId], idleMillis: commons.OptArg[Long] = OptArg.Empty, msUnixTime: commons.OptArg[Long] = OptArg.Empty, retrycount: commons.OptArg[Int] = OptArg.Empty, force: Boolean = false): Result[Seq[XEntryId]]
Executes XCLAIM
Executes XCLAIM
- Definition Classes
- StreamsApi
-
def
xclaimSingle(key: Key, group: XGroup, consumer: XConsumer, minIdleMillis: Long, id: XEntryId, idleMillis: commons.OptArg[Long] = OptArg.Empty, msUnixTime: commons.OptArg[Long] = OptArg.Empty, retrycount: commons.OptArg[Int] = OptArg.Empty, force: Boolean = false): Result[commons.Opt[XEntry]]
Executes XCLAIM
Executes XCLAIM
- Definition Classes
- StreamsApi
-
def
xdel(key: Key, ids: Iterable[XEntryId]): Result[Long]
Executes XDEL
Executes XDEL
- Definition Classes
- StreamsApi
-
def
xdel(key: Key, id: XEntryId, ids: XEntryId*): Result[Long]
Executes XDEL
Executes XDEL
- Definition Classes
- StreamsApi
-
def
xdel(key: Key, id: XEntryId): Result[Boolean]
Executes XDEL
Executes XDEL
- Definition Classes
- StreamsApi
-
def
xgroupCreate(key: Key, group: XGroup, id: commons.OptArg[XEntryId] = OptArg.Empty, mkstream: Boolean = false): Result[Unit]
Executes XGROUP CREATE
Executes XGROUP CREATE
- Definition Classes
- StreamsApi
-
def
xgroupDelconsumer(key: Key, group: XGroup, consumer: XConsumer): Result[Boolean]
Executes XGROUP DELCONSUMER
Executes XGROUP DELCONSUMER
- Definition Classes
- StreamsApi
-
def
xgroupDestroy(key: Key, group: XGroup): Result[Boolean]
Executes XGROUP DESTROY
Executes XGROUP DESTROY
- Definition Classes
- StreamsApi
-
def
xgroupSetid(key: Key, group: XGroup, id: commons.OptArg[XEntryId] = OptArg.Empty): Result[Unit]
Executes XGROUP SETID
Executes XGROUP SETID
- Definition Classes
- StreamsApi
-
def
xinfoConsumers(key: Key, group: XGroup): Result[Seq[XConsumerInfo]]
Executes XINFO CONSUMERS
Executes XINFO CONSUMERS
- Definition Classes
- StreamsApi
-
def
xinfoGroups(key: Key): Result[Seq[XGroupInfo]]
Executes XINFO GROUPS
Executes XINFO GROUPS
- Definition Classes
- StreamsApi
-
def
xinfoStream(key: Key): Result[XStreamInfo[Record]]
Executes XINFO STREAM
Executes XINFO STREAM
- Definition Classes
- StreamsApi
-
def
xlen(key: Key): Result[Long]
Executes XLEN
Executes XLEN
- Definition Classes
- StreamsApi
-
def
xpending(key: Key, group: XGroup): Result[XPendingOverview]
Executes XPENDING
Executes XPENDING
- Definition Classes
- StreamsApi
-
def
xpendingEntries(key: Key, group: XGroup, count: Int, start: commons.OptArg[XEntryId] = OptArg.Empty, end: commons.OptArg[XEntryId] = OptArg.Empty, consumer: commons.OptArg[XConsumer] = OptArg.Empty): Result[Seq[XPendingEntry]]
Executes XPENDING
Executes XPENDING
- Definition Classes
- StreamsApi
-
def
xrange(key: Key, start: commons.OptArg[XEntryId] = OptArg.Empty, end: commons.OptArg[XEntryId] = OptArg.Empty, count: commons.OptArg[Int] = OptArg.Empty): Result[Seq[XEntry]]
Executes XRANGE
Executes XRANGE
- Definition Classes
- StreamsApi
-
def
xread(streams: Iterable[(Key, commons.Opt[XEntryId])], blockMillis: commons.OptArg[Int] = OptArg.Empty, count: commons.OptArg[Int] = OptArg.Empty): Result[commons.BMap[Key, Seq[XEntry]]]
Executes XREAD
Executes XREAD
- Definition Classes
- StreamsApi
-
def
xreadSingle(key: Key, id: commons.Opt[XEntryId], blockMillis: commons.OptArg[Int] = OptArg.Empty, count: commons.OptArg[Int] = OptArg.Empty): Result[Seq[XEntry]]
Executes XREAD
Executes XREAD
- Definition Classes
- StreamsApi
-
def
xreadgroup(group: XGroup, consumer: XConsumer, streams: Iterable[(Key, commons.Opt[XEntryId])], blockMillis: commons.OptArg[Int] = OptArg.Empty, count: commons.OptArg[Int] = OptArg.Empty): Result[commons.BMap[Key, Seq[XEntry]]]
Executes XREADGROUP
Executes XREADGROUP
- Definition Classes
- StreamsApi
-
def
xreadgroupSingle(key: Key, group: XGroup, consumer: XConsumer, id: commons.OptArg[XEntryId] = OptArg.Empty, blockMillis: commons.OptArg[Int] = OptArg.Empty, count: commons.OptArg[Int] = OptArg.Empty): Result[Seq[XEntry]]
Executes XREADGROUP
Executes XREADGROUP
- Definition Classes
- StreamsApi
-
def
xrevrange(key: Key, end: commons.OptArg[XEntryId] = OptArg.Empty, start: commons.OptArg[XEntryId] = OptArg.Empty, count: commons.OptArg[Int] = OptArg.Empty): Result[Seq[XEntry]]
Executes XREVRANGE
Executes XREVRANGE
- Definition Classes
- StreamsApi
-
def
xtrim(key: Key, maxlen: XMaxlen): Result[Long]
Executes XTRIM
Executes XTRIM
- Definition Classes
- StreamsApi
-
def
xtrim(key: Key, maxlen: Long, approx: Boolean = true): Result[Long]
Executes XTRIM
Executes XTRIM
- Definition Classes
- StreamsApi
-
def
zadd(key: Key, memberScores: Iterable[(Value, Double)], existence: commons.OptArg[Boolean] = OptArg.Empty, changed: Boolean = false): Result[Int]
Executes ZADD or simply returns 0 when
memberScores
is emptyExecutes ZADD or simply returns 0 when
memberScores
is empty- Definition Classes
- SortedSetsApi
-
def
zadd(key: Key, score: Double, members: Iterable[Value]): Result[Int]
Executes ZADD or simply returns 0 when
members
is emptyExecutes ZADD or simply returns 0 when
members
is empty- Definition Classes
- SortedSetsApi
-
def
zadd(key: Key, score: Double, member: Value, members: Value*): Result[Int]
Executes ZADD
Executes ZADD
- Definition Classes
- SortedSetsApi
-
def
zadd(key: Key, member: Value, score: Double): Result[Boolean]
Executes ZADD
Executes ZADD
- Definition Classes
- SortedSetsApi
-
def
zadd(key: Key, memberScore: (Value, Double), memberScores: (Value, Double)*): Result[Int]
Executes ZADD
Executes ZADD
- Definition Classes
- SortedSetsApi
-
def
zaddIncr(key: Key, member: Value, score: Double, existence: commons.OptArg[Boolean] = OptArg.Empty): Result[commons.Opt[Double]]
Executes ZADD
Executes ZADD
- Definition Classes
- SortedSetsApi
-
def
zcard(key: Key): Result[Long]
Executes ZCARD
Executes ZCARD
- Definition Classes
- SortedSetsApi
-
def
zcount(key: Key, min: ScoreLimit = ScoreLimit.MinusInf, max: ScoreLimit = ScoreLimit.PlusInf): Result[Long]
Executes ZCOUNT
Executes ZCOUNT
- Definition Classes
- SortedSetsApi
-
def
zincrby(key: Key, increment: Double, member: Value): Result[Double]
Executes ZINCRBY
Executes ZINCRBY
- Definition Classes
- SortedSetsApi
-
def
zinterstore(destination: Key, keys: Iterable[Key], aggregation: commons.OptArg[Aggregation] = OptArg.Empty): Result[Long]
Executes ZINTERSTORE NOTE:
keys
MUST NOT be emptyExecutes ZINTERSTORE NOTE:
keys
MUST NOT be empty- Definition Classes
- SortedSetsApi
-
def
zinterstore(destination: Key, key: Key, keys: Key*): Result[Long]
Executes ZINTERSTORE
Executes ZINTERSTORE
- Definition Classes
- SortedSetsApi
-
def
zinterstoreWeights(destination: Key, keysWeights: Iterable[(Key, Double)], aggregation: commons.OptArg[Aggregation] = OptArg.Empty): Result[Long]
Executes ZINTERSTORE NOTE:
keysWeights
MUST NOT be emptyExecutes ZINTERSTORE NOTE:
keysWeights
MUST NOT be empty- Definition Classes
- SortedSetsApi
-
def
zinterstoreWeights(destination: Key, keyWeight: (Key, Double), keysWeights: (Key, Double)*): Result[Long]
Executes ZINTERSTORE
Executes ZINTERSTORE
- Definition Classes
- SortedSetsApi
-
def
zlexcount(key: Key, min: LexLimit[Value] = LexLimit.MinusInf, max: LexLimit[Value] = LexLimit.PlusInf): Result[Long]
Executes ZLEXCOUNT
Executes ZLEXCOUNT
- Definition Classes
- SortedSetsApi
-
def
zpopmax(key: Key, count: Long): Result[Seq[(Value, Double)]]
Executes ZPOPMAX
Executes ZPOPMAX
- Definition Classes
- SortedSetsApi
-
def
zpopmax(key: Key): Result[commons.Opt[(Value, Double)]]
Executes ZPOPMAX
Executes ZPOPMAX
- Definition Classes
- SortedSetsApi
-
def
zpopmin(key: Key, count: Long): Result[Seq[(Value, Double)]]
Executes ZPOPMIN
Executes ZPOPMIN
- Definition Classes
- SortedSetsApi
-
def
zpopmin(key: Key): Result[commons.Opt[(Value, Double)]]
Executes ZPOPMIN]
Executes ZPOPMIN]
- Definition Classes
- SortedSetsApi
-
def
zrange(key: Key, start: Long = 0, stop: Long = -1): Result[Seq[Value]]
Executes ZRANGE
Executes ZRANGE
- Definition Classes
- SortedSetsApi
-
def
zrangeWithscores(key: Key, start: Long = 0, stop: Long = -1): Result[Seq[(Value, Double)]]
Executes ZRANGE
Executes ZRANGE
- Definition Classes
- SortedSetsApi
-
def
zrangebylex(key: Key, min: LexLimit[Value] = LexLimit.MinusInf, max: LexLimit[Value] = LexLimit.PlusInf, limit: commons.OptArg[Limit] = OptArg.Empty): Result[Seq[Value]]
Executes ZRANGEBYLEX
Executes ZRANGEBYLEX
- Definition Classes
- SortedSetsApi
-
def
zrangebyscore(key: Key, min: ScoreLimit = ScoreLimit.MinusInf, max: ScoreLimit = ScoreLimit.PlusInf, limit: commons.OptArg[Limit] = OptArg.Empty): Result[Seq[Value]]
Executes ZRANGEBYSCORE
Executes ZRANGEBYSCORE
- Definition Classes
- SortedSetsApi
-
def
zrangebyscoreWithscores(key: Key, min: ScoreLimit = ScoreLimit.MinusInf, max: ScoreLimit = ScoreLimit.PlusInf, limit: commons.OptArg[Limit] = OptArg.Empty): Result[Seq[(Value, Double)]]
Executes ZRANGEBYSCORE
Executes ZRANGEBYSCORE
- Definition Classes
- SortedSetsApi
-
def
zrank(key: Key, member: Value): Result[commons.Opt[Long]]
Executes ZRANK
Executes ZRANK
- Definition Classes
- SortedSetsApi
-
def
zrem(key: Key, members: Iterable[Value]): Result[Int]
Executes ZREM or simply returns 0 when
members
is emptyExecutes ZREM or simply returns 0 when
members
is empty- Definition Classes
- SortedSetsApi
-
def
zrem(key: Key, member: Value, members: Value*): Result[Int]
Executes ZREM
Executes ZREM
- Definition Classes
- SortedSetsApi
-
def
zrem(key: Key, member: Value): Result[Boolean]
Executes ZREM
Executes ZREM
- Definition Classes
- SortedSetsApi
-
def
zremrangebylex(key: Key, min: LexLimit[Value] = LexLimit.MinusInf, max: LexLimit[Value] = LexLimit.PlusInf): Result[Long]
Executes ZREMRANGEBYLEX
Executes ZREMRANGEBYLEX
- Definition Classes
- SortedSetsApi
-
def
zremrangebyrank(key: Key, start: Long = 0, stop: Long = -1): Result[Long]
Executes ZREMRANGEBYRANK
Executes ZREMRANGEBYRANK
- Definition Classes
- SortedSetsApi
-
def
zremrangebyscore(key: Key, min: ScoreLimit = ScoreLimit.MinusInf, max: ScoreLimit = ScoreLimit.PlusInf): Result[Long]
Executes ZREMRANGEBYSCORE
Executes ZREMRANGEBYSCORE
- Definition Classes
- SortedSetsApi
-
def
zrevrange(key: Key, start: Long = 0, stop: Long = -1): Result[Seq[Value]]
Executes ZREVRANGE
Executes ZREVRANGE
- Definition Classes
- SortedSetsApi
-
def
zrevrangeWithscores(key: Key, start: Long = 0, stop: Long = -1): Result[Seq[(Value, Double)]]
Executes ZREVRANGE
Executes ZREVRANGE
- Definition Classes
- SortedSetsApi
-
def
zrevrangebylex(key: Key, max: LexLimit[Value] = LexLimit.PlusInf, min: LexLimit[Value] = LexLimit.MinusInf, limit: commons.OptArg[Limit] = OptArg.Empty): Result[Seq[Value]]
Executes ZREVRANGEBYLEX
Executes ZREVRANGEBYLEX
- Definition Classes
- SortedSetsApi
-
def
zrevrangebyscore(key: Key, max: ScoreLimit = ScoreLimit.PlusInf, min: ScoreLimit = ScoreLimit.MinusInf, limit: commons.OptArg[Limit] = OptArg.Empty): Result[Seq[Value]]
Executes ZREVRANGEBYSCORE
Executes ZREVRANGEBYSCORE
- Definition Classes
- SortedSetsApi
-
def
zrevrangebyscoreWithscores(key: Key, max: ScoreLimit = ScoreLimit.PlusInf, min: ScoreLimit = ScoreLimit.MinusInf, limit: commons.OptArg[Limit] = OptArg.Empty): Result[Seq[(Value, Double)]]
Executes ZREVRANGEBYSCORE
Executes ZREVRANGEBYSCORE
- Definition Classes
- SortedSetsApi
-
def
zrevrank(key: Key, member: Value): Result[commons.Opt[Long]]
Executes ZREVRANK
Executes ZREVRANK
- Definition Classes
- SortedSetsApi
-
def
zscan(key: Key, cursor: Cursor, matchPattern: commons.OptArg[Value] = OptArg.Empty, count: commons.OptArg[Int] = OptArg.Empty): Result[(Cursor, Seq[(Value, Double)])]
Executes ZSCAN
Executes ZSCAN
- Definition Classes
- SortedSetsApi
-
def
zscore(key: Key, member: Value): Result[commons.Opt[Double]]
Executes ZSCORE
Executes ZSCORE
- Definition Classes
- SortedSetsApi
-
def
zunionstore(destination: Key, keys: Iterable[Key], aggregation: commons.OptArg[Aggregation] = OptArg.Empty): Result[Long]
Executes ZUNIONSTORE NOTE:
keys
MUST NOT be emptyExecutes ZUNIONSTORE NOTE:
keys
MUST NOT be empty- Definition Classes
- SortedSetsApi
-
def
zunionstore(destination: Key, key: Key, keys: Key*): Result[Long]
Executes ZUNIONSTORE
Executes ZUNIONSTORE
- Definition Classes
- SortedSetsApi
-
def
zunionstoreWeights(destination: Key, keysWeights: Iterable[(Key, Double)], aggregation: commons.OptArg[Aggregation] = OptArg.Empty): Result[Long]
Executes ZUNIONSTORE NOTE:
keysWeights
MUST NOT be emptyExecutes ZUNIONSTORE NOTE:
keysWeights
MUST NOT be empty- Definition Classes
- SortedSetsApi
-
def
zunionstoreWeights(destination: Key, keyWeight: (Key, Double), keysWeights: (Key, Double)*): Result[Long]
Executes ZUNIONSTORE
Executes ZUNIONSTORE
- Definition Classes
- SortedSetsApi
-
object
XEntry
- Definition Classes
- StreamsApi