class Batches[S <: RedisSerialization] extends AbstractRedisApi[S] with RedisConnectionApi with RedisBatchApi
- Alphabetic
- By Inheritance
- Batches
- RedisBatchApi
- RedisConnectionApi
- ConnectionScriptingApi
- ConnectionServerApi
- ConnectionConnectionApi
- ConnectionClusterApi
- RedisOperationApi
- TransactionApi
- RedisNodeApi
- NodeScriptingApi
- NodeConnectionApi
- NodeClusterApi
- NodeServerApi
- NodeKeysApi
- RedisKeyedApi
- StreamsApi
- HyperLogLogApi
- SetsApi
- ListsApi
- SortedSetsApi
- HashesApi
- KeyedScriptingApi
- GeoApi
- KeyedClusterApi
- StringsApi
- KeyedKeysApi
- AbstractRedisApi
- ApiSubset
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Instance Constructors
- new Batches(serialization: S)
Type Members
-
type
Field = S.Field
- Definition Classes
- ApiSubset
-
type
Key = S.Key
- Definition Classes
- ApiSubset
-
type
Record = S.Record
- Definition Classes
- ApiSubset
-
type
Result[A] = RedisBatch[A]
The type constructor into which a result of each command is wrapped.
The type constructor into which a result of each command is wrapped. For example if
Result
isFuture
, then incr returnsFuture[Long]
.- Definition Classes
- RedisBatchApi → ApiSubset
-
type
Self[S0 <: RedisSerialization] = Batches[S0]
- Definition Classes
- Batches → AbstractRedisApi
-
type
Value = S.Value
- Definition Classes
- ApiSubset
-
type
WithField[F] = Self[S.WithField[F]]
- Definition Classes
- AbstractRedisApi
-
type
WithKey[K] = Self[S.WithKey[K]]
- Definition Classes
- AbstractRedisApi
-
type
WithRecord[R] = Self[S.WithRecord[R]]
- Definition Classes
- AbstractRedisApi
-
type
WithValue[V] = Self[S.WithValue[V]]
- Definition Classes
- AbstractRedisApi
-
type
XEntry = commands.XEntry[Record]
- Definition Classes
- StreamsApi
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
auth(password: String): Result[Unit]
Executes AUTH
Executes AUTH
- Definition Classes
- ConnectionConnectionApi
-
def
bgrewriteaof: Result[String]
Executes BGREWRITEAOF
Executes BGREWRITEAOF
- Definition Classes
- NodeServerApi
-
def
bgsave(schedule: Boolean = false): Result[String]
Executes BGSAVE
Executes BGSAVE
- Definition Classes
- NodeServerApi
-
def
bgsave: Result[String]
Executes BGSAVE
Executes BGSAVE
- Definition Classes
- NodeServerApi
-
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
clientGetname: Result[commons.Opt[String]]
Executes CLIENT GETNAME
Executes CLIENT GETNAME
- Definition Classes
- ConnectionServerApi
-
def
clientId: Result[ClientId]
Executes CLIENT ID
Executes CLIENT ID
- Definition Classes
- NodeServerApi
-
def
clientKill(filters: ClientFilter*): Result[Int]
Executes CLIENT KILL
Executes CLIENT KILL
- Definition Classes
- NodeServerApi
-
def
clientKill(addr: ClientAddress): Result[Unit]
Executes CLIENT KILL
Executes CLIENT KILL
- Definition Classes
- NodeServerApi
-
def
clientList: Result[Seq[ClientInfo]]
Executes CLIENT LIST
Executes CLIENT LIST
- Definition Classes
- NodeServerApi
-
def
clientPause(timeout: Long): Result[Unit]
Executes CLIENT PAUSE
Executes CLIENT PAUSE
- Definition Classes
- NodeServerApi
-
def
clientSetname(connectionName: String): Result[Unit]
Executes CLIENT SETNAME
Executes CLIENT SETNAME
- Definition Classes
- ConnectionServerApi
-
def
clientUnblock(clientId: ClientId, modifier: commons.OptArg[UnblockModifier] = OptArg.Empty): Result[Boolean]
Executes CLIENT UNBLOCK
Executes CLIENT UNBLOCK
- Definition Classes
- NodeServerApi
-
def
clone(): AnyRef
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @native() @throws( ... )
-
def
clusterAddslots(slots: Iterable[Int]): Result[Unit]
Executes CLUSTER ADDSLOTS or does nothing when
slots
is empty.Executes CLUSTER ADDSLOTS or does nothing when
slots
is empty.- Definition Classes
- NodeClusterApi
-
def
clusterAddslots(slot: Int, slots: Int*): Result[Unit]
Executes CLUSTER ADDSLOTS
Executes CLUSTER ADDSLOTS
- Definition Classes
- NodeClusterApi
-
def
clusterCountFailureReports(nodeId: NodeId): Result[Long]
Executes CLUSTER COUNT-FAILURE-REPORTS
Executes CLUSTER COUNT-FAILURE-REPORTS
- Definition Classes
- NodeClusterApi
-
def
clusterCountkeysinslot(slot: Int): Result[Long]
Executes CLUSTER COUNTKEYSINSLOT
Executes CLUSTER COUNTKEYSINSLOT
- Definition Classes
- NodeClusterApi
-
def
clusterDelslots(slots: Iterable[Int]): Result[Unit]
Executes CLUSTER DELSLOTS or does nothing when
slots
is emptyExecutes CLUSTER DELSLOTS or does nothing when
slots
is empty- Definition Classes
- NodeClusterApi
-
def
clusterDelslots(slot: Int, slots: Int*): Result[Unit]
Executes CLUSTER DELSLOTS
Executes CLUSTER DELSLOTS
- Definition Classes
- NodeClusterApi
-
def
clusterFailover(option: commons.OptArg[FailoverOption] = OptArg.Empty): Result[Unit]
Executes CLUSTER FAILOVER
Executes CLUSTER FAILOVER
- Definition Classes
- NodeClusterApi
-
def
clusterFailover: Result[Unit]
Executes CLUSTER FAILOVER
Executes CLUSTER FAILOVER
- Definition Classes
- NodeClusterApi
-
def
clusterFlushslots: Result[Unit]
- Definition Classes
- NodeClusterApi
-
def
clusterForget(nodeId: NodeId): Result[Unit]
Executes CLUSTER FORGET
Executes CLUSTER FORGET
- Definition Classes
- NodeClusterApi
-
def
clusterGetkeysinslot(slot: Int, count: Int): Result[Seq[Key]]
Executes CLUSTER GETKEYSINSLOT
Executes CLUSTER GETKEYSINSLOT
- Definition Classes
- NodeClusterApi
-
def
clusterInfo: Result[ClusterStateInfo]
Executes CLUSTER INFO
Executes CLUSTER INFO
- Definition Classes
- NodeClusterApi
-
def
clusterKeyslot(key: Key): Result[Int]
Executes CLUSTER KEYSLOT
Executes CLUSTER KEYSLOT
- Definition Classes
- KeyedClusterApi
-
def
clusterMeet(address: NodeAddress): Result[Unit]
Executes CLUSTER MEET
Executes CLUSTER MEET
- Definition Classes
- NodeClusterApi
-
def
clusterMyid: Result[NodeId]
- Definition Classes
- NodeClusterApi
-
def
clusterNodes: Result[Seq[NodeInfo]]
Executes CLUSTER NODES
Executes CLUSTER NODES
- Definition Classes
- NodeClusterApi
-
def
clusterReplicate(nodeId: NodeId): Result[Unit]
Executes CLUSTER REPLICATE
Executes CLUSTER REPLICATE
- Definition Classes
- NodeClusterApi
-
def
clusterReset(hard: Boolean = false): Result[Unit]
Executes CLUSTER RESET
Executes CLUSTER RESET
- Definition Classes
- NodeClusterApi
-
def
clusterReset: Result[Unit]
Executes CLUSTER RESET
Executes CLUSTER RESET
- Definition Classes
- NodeClusterApi
-
def
clusterSaveconfig: Result[Unit]
Executes CLUSTER SAVECONFIG
Executes CLUSTER SAVECONFIG
- Definition Classes
- NodeClusterApi
-
def
clusterSetConfigEpoch(configEpoch: Long): Result[Unit]
Executes CLUSTER SET-CONFIG-EPOCH
Executes CLUSTER SET-CONFIG-EPOCH
- Definition Classes
- NodeClusterApi
-
def
clusterSetslot(slot: Int, subcommand: SetslotCmd): Result[Unit]
Executes CLUSTER SETSLOT
Executes CLUSTER SETSLOT
- Definition Classes
- NodeClusterApi
-
def
clusterSlaves(nodeId: NodeId): Result[Seq[NodeInfo]]
Executes CLUSTER SLAVES
Executes CLUSTER SLAVES
- Definition Classes
- NodeClusterApi
-
def
clusterSlots: Result[Seq[SlotRangeMapping]]
Executes CLUSTER SLOTS
Executes CLUSTER SLOTS
- Definition Classes
- NodeClusterApi
-
def
command: Result[Seq[CommandInfo]]
Executes COMMAND
Executes COMMAND
- Definition Classes
- NodeServerApi
-
def
commandCount: Result[Int]
Executes COMMAND COUNT
Executes COMMAND COUNT
- Definition Classes
- NodeServerApi
-
def
commandGetkeys(command: Seq[ByteString]): Result[Seq[Key]]
Executes COMMAND GETKEYS
Executes COMMAND GETKEYS
- Definition Classes
- NodeServerApi
-
def
commandGetkeys(command: RawCommand): Result[Seq[Key]]
Executes COMMAND GETKEYS
Executes COMMAND GETKEYS
- Definition Classes
- NodeServerApi
-
def
commandInfo(commandNames: Seq[String]): Result[Seq[CommandInfo]]
Executes COMMAND INFO
Executes COMMAND INFO
- Definition Classes
- NodeServerApi
-
def
commandInfo(commandName: String, commandNames: String*): Result[Seq[CommandInfo]]
Executes COMMAND INFO
Executes COMMAND INFO
- Definition Classes
- NodeServerApi
-
def
commandInfo(commandName: String): Result[CommandInfo]
Executes COMMAND INFO
Executes COMMAND INFO
- Definition Classes
- NodeServerApi
-
def
configGet(parameter: String): Result[Seq[(String, String)]]
Executes CONFIG GET
Executes CONFIG GET
- Definition Classes
- NodeServerApi
-
def
configResetstat: Result[Unit]
Executes CONFIG RESETSTAT
Executes CONFIG RESETSTAT
- Definition Classes
- NodeServerApi
-
def
configRewrite: Result[Unit]
Executes CONFIG REWRITE
Executes CONFIG REWRITE
- Definition Classes
- NodeServerApi
-
def
configSet(parameter: String, value: String): Result[Unit]
Executes CONFIG SET
Executes CONFIG SET
- Definition Classes
- NodeServerApi
-
def
dbsize: Result[Long]
Executes DBSIZE
Executes DBSIZE
- Definition Classes
- NodeServerApi
-
def
debugSegfault: Result[Nothing]
Executes DEBUG SEGFAULT
Executes DEBUG SEGFAULT
- Definition Classes
- NodeServerApi
-
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
-
def
echo(message: ByteString): Result[ByteString]
Executes ECHO
Executes ECHO
- Definition Classes
- NodeConnectionApi
-
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
execute[A](command: RedisCommand[A]): RedisBatch[A]
- Definition Classes
- RedisBatchApi → ApiSubset
-
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
-
final
def
fieldType[F](implicit arg0: RedisDataCodec[F]): WithField[F]
- Definition Classes
- AbstractRedisApi
-
def
finalize(): Unit
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
def
flushall(async: Boolean = false): Result[Unit]
Executes FLUSHALL
Executes FLUSHALL
- Definition Classes
- NodeServerApi
-
def
flushall: Result[Unit]
Executes FLUSHALL
Executes FLUSHALL
- Definition Classes
- NodeServerApi
-
def
flushdb(async: Boolean = false): Result[Unit]
Executes FLUSHDB
Executes FLUSHDB
- Definition Classes
- NodeServerApi
-
def
flushdb: Result[Unit]
Executes FLUSHDB
Executes FLUSHDB
- Definition Classes
- NodeServerApi
-
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
-
def
info[T >: FullRedisInfo <: RedisInfo](section: RedisInfoSection[T]): Result[T]
Executes INFO
Executes INFO
- Definition Classes
- NodeServerApi
-
def
info: Result[DefaultRedisInfo]
Executes INFO
Executes INFO
- Definition Classes
- NodeServerApi
-
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
-
final
def
keyType[K](implicit arg0: RedisDataCodec[K]): WithKey[K]
- Definition Classes
- AbstractRedisApi
-
def
keys(pattern: Key): Result[commons.BSet[Key]]
Executes KEYS
Executes KEYS
- Definition Classes
- NodeKeysApi
-
def
lastsave: Result[Long]
Executes LASTSAVE
Executes LASTSAVE
- Definition Classes
- NodeServerApi
-
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
move(key: Key, db: Int): Result[Boolean]
Executes MOVE
Executes MOVE
- Definition Classes
- NodeKeysApi
-
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
ping: Result[ByteString]
Executes PING
Executes PING
- Definition Classes
- NodeConnectionApi
-
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
-
def
quit: Result[Unit]
Executes QUIT
Executes QUIT
- Definition Classes
- ConnectionConnectionApi
-
def
randomkey: Result[commons.Opt[Key]]
Executes RANDOMKEY
Executes RANDOMKEY
- Definition Classes
- NodeKeysApi
-
def
readonly: Result[Unit]
Executes READONLY
Executes READONLY
- Definition Classes
- ConnectionClusterApi
-
def
readwrite: Result[Unit]
Executes READWRITE
Executes READWRITE
- Definition Classes
- ConnectionClusterApi
-
implicit final
def
recordCodec: RedisRecordCodec[Record]
- Attributes
- protected
- Definition Classes
- ApiSubset
-
final
def
recordType[R](implicit arg0: RedisRecordCodec[R]): WithRecord[R]
- Definition Classes
- AbstractRedisApi
-
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
replicaof(newMaster: NodeAddress): Result[Unit]
Executes REPLICAOF
Executes REPLICAOF
- Definition Classes
- NodeServerApi
-
def
replicaofNoOne: Result[Unit]
Executes REPLICAOF
Executes REPLICAOF
- Definition Classes
- NodeServerApi
-
def
restore(key: Key, ttl: Long, dumpedValue: Dumped, replace: Boolean = false): Result[Unit]
Executes RESTORE
Executes RESTORE
- Definition Classes
- KeyedKeysApi
-
def
role: Result[RedisRole]
Executes ROLE
Executes ROLE
- Definition Classes
- NodeServerApi
-
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
save: Result[Unit]
Executes SAVE
Executes SAVE
- Definition Classes
- NodeServerApi
-
def
scan(cursor: Cursor, matchPattern: commons.OptArg[Key] = OptArg.Empty, count: commons.OptArg[Long] = OptArg.Empty): Result[(Cursor, Seq[Key])]
Executes SCAN
Executes SCAN
- Definition Classes
- NodeKeysApi
-
def
scard(key: Key): Result[Long]
Executes SCARD
-
def
scriptDebug(mode: DebugMode): Result[Unit]
Executes SCRIPT DEBUG
Executes SCRIPT DEBUG
- Definition Classes
- ConnectionScriptingApi
-
def
scriptExists(hashes: Iterable[Sha1]): Result[Seq[Boolean]]
Executes SCRIPT EXISTS NOTE:
hashes
CAN be empty, Redis accepts itExecutes SCRIPT EXISTS NOTE:
hashes
CAN be empty, Redis accepts it- Definition Classes
- NodeScriptingApi
-
def
scriptExists(hash: Sha1, hashes: Sha1*): Result[Seq[Boolean]]
- Definition Classes
- NodeScriptingApi
-
def
scriptExists(hash: Sha1): Result[Boolean]
- Definition Classes
- NodeScriptingApi
-
def
scriptFlush: Result[Unit]
Executes SCRIPT FLUSH
Executes SCRIPT FLUSH
- Definition Classes
- NodeScriptingApi
-
def
scriptKill: Result[Unit]
Executes SCRIPT KILL
Executes SCRIPT KILL
- Definition Classes
- NodeScriptingApi
-
def
scriptLoad(script: RedisScript[Any]): Result[Sha1]
Executes SCRIPT LOAD
Executes SCRIPT LOAD
- Definition Classes
- NodeScriptingApi
-
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
select(index: Int): Result[Unit]
Executes SELECT
Executes SELECT
- Definition Classes
- ConnectionConnectionApi
- val serialization: S
-
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
shutdown(modifier: commons.OptArg[ShutdownModifier] = OptArg.Empty): Result[Nothing]
Executes SHUTDOWN
Executes SHUTDOWN
- Definition Classes
- NodeServerApi
-
def
shutdown: Result[Nothing]
Executes SHUTDOWN
Executes SHUTDOWN
- Definition Classes
- NodeServerApi
-
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
slaveof(newMaster: NodeAddress): Result[Unit]
Executes SLAVEOF
Executes SLAVEOF
- Definition Classes
- NodeServerApi
-
def
slaveofNoOne: Result[Unit]
Executes SLAVEOF
Executes SLAVEOF
- Definition Classes
- NodeServerApi
-
def
slowlogGet(count: commons.OptArg[Int] = OptArg.Empty): Result[Seq[SlowlogEntry]]
Executes SLOWLOG
Executes SLOWLOG
- Definition Classes
- NodeServerApi
-
def
slowlogGet: Result[Seq[SlowlogEntry]]
Executes SLOWLOG
Executes SLOWLOG
- Definition Classes
- NodeServerApi
-
def
slowlogLen: Result[Long]
Executes SLOWLOG
Executes SLOWLOG
- Definition Classes
- NodeServerApi
-
def
slowlogReset: Result[Unit]
Executes SLOWLOG
Executes SLOWLOG
- Definition Classes
- NodeServerApi
-
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
-
def
swapdb(first: Int, second: Int): Result[Unit]
Executes SWAPDB
Executes SWAPDB
- Definition Classes
- NodeConnectionApi
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
time: Result[RedisTimestamp]
Executes TIME
Executes TIME
- Definition Classes
- NodeServerApi
-
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
-
def
unwatch: Result[Unit]
Executes UNWATCH
Executes UNWATCH
- Definition Classes
- TransactionApi
-
implicit final
def
valueCodec: RedisDataCodec[Value]
- Attributes
- protected
- Definition Classes
- ApiSubset
-
final
def
valueType[V](implicit arg0: RedisDataCodec[V]): WithValue[V]
- Definition Classes
- AbstractRedisApi
-
def
wait(numslaves: Int, timeout: Long): Result[Long]
Executes WAIT
Executes WAIT
- Definition Classes
- NodeKeysApi
-
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
watch(keys: Iterable[Key]): Result[Unit]
Executes WATCH or does nothing when
keys
is empty, without sending the command to RedisExecutes WATCH or does nothing when
keys
is empty, without sending the command to Redis- Definition Classes
- TransactionApi
-
def
watch(key: Key, keys: Key*): Result[Unit]
Executes WATCH
Executes WATCH
- Definition Classes
- TransactionApi
-
def
withSerialization[S0 <: RedisSerialization](ser: S0): Batches[S0]
- Definition Classes
- Batches → AbstractRedisApi
-
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