Packages

trait RedisBatch[+A] extends AnyRef

Represents a Redis command or a set of commands sent to Redis as a single batch (usually in a single network message). RedisBatch yields a result of type A which is decoded from responses to commands from this batch. Execution of a batch may also fail for various reasons. Therefore, RedisBatch contains API that allows to recover from failures, e.g. RedisBatch.tried.

RedisBatches may be combined with each other to form bigger batches. The simpliest primitive for combining batches is RedisBatch.map2 operation while the most convenient way is by using RedisBatch.sequence operation which is powered by Sequencer typeclass.

RedisBatch can be turned into a RedisOp or executed by RedisExecutor (e.g. one of Redis client implementations).

A

result yield by this batch

Self Type
RedisBatch[A]
Linear Supertypes
AnyRef, Any
Known Subclasses
AbstractRedisCommand, CollectionBatch, ImmediateBatch, RedisBinaryCommand, RedisBooleanCommand, RedisCommand, RedisDataCommand, RedisDataSeqCommand, RedisDataSetCommand, RedisDoubleCommand, RedisEnumCommand, RedisIntCommand, RedisLongCommand, RedisNothingCommand, RedisOptCommand, RedisOptDataCommand, RedisOptDataSeqCommand, RedisOptDoubleCommand, RedisOptLongCommand, RedisOptSeqCommand, RedisOptStringCommand, RedisPositiveLongCommand, RedisRawCommand, RedisScanCommand, RedisSeqCommand, RedisSimpleStringCommand, RedisUnitCommand, SinglePackBatch, Transaction
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. RedisBatch
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Abstract Value Members

  1. abstract def decodeReplies(replies: (Int) ⇒ RedisReply, index: Index = new Index, inTransaction: Boolean = false): A
  2. abstract def rawCommandPacks: RawCommandPacks

Concrete Value Members

  1. def *>[B](other: RedisBatch[B]): RedisBatch[B]

    Merges two batches into a single batch where result of the right-hand-side batch is returned while result of left-hand-side is discarded.

    Merges two batches into a single batch where result of the right-hand-side batch is returned while result of left-hand-side is discarded. Useful when left-hand-side returns Unit. NOTE: errors for left-hand-side are NOT discarded, use ignoreFailures on it if that's your intention.

  2. def <*[B](other: RedisBatch[B]): RedisBatch[A]

    Merges two batches into a single batch where result of the left-hand-side batch is returned while result of right-hand-side is discarded.

    Merges two batches into a single batch where result of the left-hand-side batch is returned while result of right-hand-side is discarded. Useful when right-hand-side returns Unit. NOTE: errors for right-hand-side are NOT discarded, use ignoreFailures on it if that's your intention.

  3. def <*>[B, C](other: RedisBatch[B])(f: (A, B) ⇒ C): RedisBatch[C]

    This is a symbolic alias for map2.

    This is a symbolic alias for map2. The symbol (along with *> and <*) is inspired by its Haskell equivalent.

  4. def asking: RedisBatch[A]

    Ensures that every keyed command in this batch is prepended with ASKING special command.

    Ensures that every keyed command in this batch is prepended with ASKING special command. This is necessary only when manually handling Redis Cluster redirections.

  5. def atomic: RedisBatch[A]

    Returns a batch which invokes the same commands as this batch but atomically.

    Returns a batch which invokes the same commands as this batch but atomically. If this batch is already atomic then it's returned unchanged. Otherwise, it's wrapped into a Redis transaction (MULTI-EXEC block). Empty batches, single-command batches and transactions are atomic by themselves and therefore are returned unchanged.

  6. def failed: RedisBatch[Throwable]
  7. def ignoreFailures: RedisBatch[Unit]
  8. def map[B](f: (A) ⇒ B): RedisBatch[B]
  9. def map2[B, C](other: RedisBatch[B])(f: (A, B) ⇒ C): RedisBatch[C]

    Merges two batches into one.

    Merges two batches into one. Provided function is applied on results of the batches being merged to obtain result of the merged batch. map2 is the fundamental primitive for composing multiple batches into one.

  10. def operation: RedisOp[A]

    Transforms this batch into a RedisOp.

  11. def recover[B >: A](f: PartialFunction[Throwable, B]): RedisBatch[B]
  12. def transaction: RedisBatch[A]

    Wraps this batch into a Redis transaction, i.e.

    Wraps this batch into a Redis transaction, i.e. ensures that it's executed inside a MULTI-EXEC block. NOTE: If you simply want to ensure atomicity, use atomic. NOTE: You can safely nest transactions, the driver will make sure that there are no nested MULTI-EXEC blocks on the wire.

  13. def transform[B](fun: (commons.Try[A]) ⇒ commons.Try[B]): RedisBatch[B]
  14. def tried: RedisBatch[commons.Try[A]]
  15. def zip[B](other: RedisBatch[B]): RedisBatch[(A, B)]