lettucef-core/dev.naoh.lettucef.core.async/KeyCommands

KeyCommands

trait KeyCommands[F[_], K, V] extends CommandsDeps[F, K, V] with KeyCommandsF[<none>, K, V]
trait KeyCommandsF[<none>, K, V]
trait CommandsDeps[F, K, V]
class Object
trait Matchable
class Any
class RedisAsyncCommandsF[F, K, V]

Value members

Concrete methods

def `type`(key: K): F[F[String]]
def copy(source: K, destination: K): F[F[Boolean]]
def copy(source: K, destination: K, copyArgs: CopyArgs): F[F[Boolean]]
def del(keys: K*): F[F[Long]]
def dump(key: K): F[F[Option[Array[Byte]]]]
def exists(keys: K*): F[F[Long]]
def expire(key: K, seconds: Long): F[F[Boolean]]
def expire(key: K, seconds: Duration): F[F[Boolean]]
def expireat(key: K, timestamp: Long): F[F[Boolean]]
def expireat(key: K, timestamp: Instant): F[F[Boolean]]
def keys(pattern: K): F[F[Seq[K]]]
def migrate(host: String, port: Int, key: K, db: Int, timeout: Long): F[F[String]]
def migrate(host: String, port: Int, db: Int, timeout: Long, migrateArgs: MigrateArgs[K]): F[F[String]]
def move(key: K, db: Int): F[F[Boolean]]
def objectEncoding(key: K): F[F[Option[String]]]
def objectFreq(key: K): F[F[Long]]
def objectIdletime(key: K): F[F[Long]]
def objectRefcount(key: K): F[F[Long]]
def persist(key: K): F[F[Boolean]]
def pexpire(key: K, milliseconds: Long): F[F[Boolean]]
def pexpire(key: K, milliseconds: Duration): F[F[Boolean]]
def pexpireat(key: K, timestamp: Long): F[F[Boolean]]
def pexpireat(key: K, timestamp: Instant): F[F[Boolean]]
def pttl(key: K): F[F[Long]]
def randomkey(): F[F[Option[K]]]
def rename(key: K, newKey: K): F[F[String]]
def renamenx(key: K, newKey: K): F[F[Boolean]]
def restore(key: K, ttl: Long, value: Array[Byte]): F[F[String]]
def restore(key: K, value: Array[Byte], args: RestoreArgs): F[F[String]]
def scan(): F[F[RedisScanCursor[K]]]
def scan(scanArgs: ScanArgs): F[F[RedisScanCursor[K]]]
def scan(scanCursor: ScanCursor, scanArgs: ScanArgs): F[F[RedisScanCursor[K]]]
def scan(scanCursor: ScanCursor): F[F[RedisScanCursor[K]]]
def sort(key: K): F[F[Seq[V]]]
def sort(key: K, sortArgs: SortArgs): F[F[Seq[V]]]
def sortStore(key: K, sortArgs: SortArgs, destination: K): F[F[Long]]
def touch(keys: K*): F[F[Long]]
def ttl(key: K): F[F[Long]]

Abstract fields

protected
val underlying: RedisKeyAsyncCommands[K, V]

Inherited fields

protected
val dispatchHelper: ManualDispatchHelper[K, V]
Inherited from
CommandsDeps

Implicits

Inherited implicits

implicit protected
val _async: Async[F]
Inherited from
CommandsDeps