HashesApi

abstract def execute[A](command: RedisCommand[A]): Result[A]

abstract val serialization: RedisSerialization

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

implicit final def fieldCodec: RedisDataCodec[Field]

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

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]

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

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 when fields 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

final def isInstanceOf[T0]: Boolean

implicit def iterableTailOps[T](tail: Iterable[T]): IterableTailOps[T]

implicit def iteratorTailOps[T](tail: Iterator[T]): IteratorTailOps[T]

implicit final def keyCodec: RedisDataCodec[Key]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

implicit final def recordCodec: RedisRecordCodec[Record]

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

implicit final def valueCodec: RedisDataCodec[Value]

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit