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

KeyCommands

trait KeyCommands[F[_], K, V] extends CommandsDeps[F, K, V] with KeyCommandsF[F, K, V]
trait KeyCommandsF[F, K, V]
trait CommandsDeps[F, K, V]
class Object
trait Matchable
class Any
class RedisSyncCommandsF[F, K, V]

Value members

Concrete methods

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