🥮 mooncakes.io

redis

A modern, high performance Redis client for MoonBit.

redis
client
valkey
moon add oboard/redis@0.1.5
Download zip
Author
Version
0.1.5
License
Apache-2.0
Repository
Last updated
2 months ago
Downloads
41

Dependencies

README

#oboard/redis

moonbit-redis is a modern, high performance Redis client for MoonBit.

#Usage

#Basic Example

///|
async test "string_set_get" {
  @async.with_task_group(async fn(_root) {
    let client = connect("localhost", 6379)
    defer client.close()

    // SET
    let set_result = client.set("test:string", "hello_world")
    assert_true(set_result is Ok("OK"))

    // GET
    let get_result = client.get("test:string")
    assert_true(get_result is Ok("hello_world"))

    // Cleanup
    let _ = client.del(["test:string"])
  })
}

#Ping

///|
async test "ping" {
  @async.with_task_group(async fn(_root) {
    let client = @redis.connect("localhost", 6379)
    defer client.close()
    let pong = client.ping()
    assert_true(pong is Ok("PONG"))
  })
}

#
RedisArray

source
type RedisArray = Result[Array[String], String]

#
RedisBool

source
type RedisBool = Result[Bool, String]

#
RedisBulkString

source
type RedisBulkString = Result[String?, String]

#
RedisHash

source
type RedisHash = Result[Map[String, String], String]

#
RedisInt

source
type RedisInt = Result[Int, String]

#
RedisJson

source
type RedisJson = Result[Json, String]

#
RedisResult

source
type RedisResult[T] = Result[T, String]

Redis命令的结果类型

#
RedisStreamMessageArray

source
type RedisStreamMessageArray = Result[Array[RedisStreamMessage], String]

#
RedisStreamResult

source
type RedisStreamResult = Result[RedisStream, String]

#
RedisString

source
type RedisString = Result[String, String]

常用的具体返回类型

#
Bit

source
pub(all) enum Bit {
  Zero
  One
}

impl Show for Bit

#
BitFieldEncoding

source
pub(all) enum BitFieldEncoding {
  U8
  U16
  U32
  U64
  I8
  I16
  I32
  I64
}

#
BitFieldOperation

source
pub(all) enum BitFieldOperation {
  Get(BitFieldEncoding, Int)
  Set(BitFieldEncoding, Int, Bit)
  Incrby(BitFieldEncoding, Int, Int)
  Overflow(String)
}

#
BitFieldOperation::to_array

source
fn BitFieldOperation::to_array(self : BitFieldOperation) -> Array[String]

#
GeoCoordinates

source
pub(all) struct GeoCoordinates {
  longitude : Double
  latitude : Double
}

#
GeoCoordinates::to_array

source
fn GeoCoordinates::to_array(self : GeoCoordinates) -> Array[String]

#
GeoSearchByBox

source
pub(all) struct GeoSearchByBox {
  width : Int
  height : Int
  unit : GeoUnits
}

#
GeoSearchByBox::to_array

source
fn GeoSearchByBox::to_array(self : GeoSearchByBox) -> Array[String]

#
GeoUnits

source
pub(all) enum GeoUnits {
  Meters
  Kilometers
  Miles
  Feet
}

impl Show for GeoUnits

#
RedisClient

source
pub struct RedisClient {
  conn : 
Tcp
}

#
RedisClient::append

source
async fn RedisClient::append(self : RedisClient, key : String, value : String) -> Result[Int, String]

#
RedisClient::auth

source
async fn RedisClient::auth(self : RedisClient, password : String) -> Result[String, String]

#
RedisClient::auth_username

source
async fn RedisClient::auth_username(self : RedisClient, username : String, password : String) -> Result[String, String]

#
RedisClient::bgrewriteaof

source
async fn RedisClient::bgrewriteaof(self : RedisClient) -> RedisValue

#
RedisClient::bgsave

source
async fn RedisClient::bgsave(self : RedisClient) -> RedisValue

#
RedisClient::bitcount

source
async fn RedisClient::bitcount(self : RedisClient, key : String) -> Result[Int, String]

#
RedisClient::bitcount_range

source
async fn RedisClient::bitcount_range(self : RedisClient, key : String, start : Int, end : Int) -> Result[Int, String]

#
RedisClient::bitfield

source
async fn RedisClient::bitfield(self : RedisClient, key : String, operations : Array[BitFieldOperation]) -> Result[Array[String], String]

#
RedisClient::bitfield_ro

source
async fn RedisClient::bitfield_ro(self : RedisClient, key : String, operations : Array[String]) -> Result[Array[String], String]

#
RedisClient::bitop

source
async fn RedisClient::bitop(self : RedisClient, operation : String, destkey : String, keys : Array[String]) -> Result[Int, String]

#
RedisClient::bitpos

source
async fn RedisClient::bitpos(self : RedisClient, key : String, bit : Bit) -> Result[Int, String]

#
RedisClient::bitpos_range

source
async fn RedisClient::bitpos_range(self : RedisClient, key : String, bit : Bit, start : Int, end : Int) -> Result[Int, String]

#
RedisClient::blmove

source
async fn RedisClient::blmove(self : RedisClient, source : String, destination : String, wherefrom~ : Int, whereto~ : Int, timeout~ : Int) -> RedisValue

#
RedisClient::blmpop

source
async fn RedisClient::blmpop(self : RedisClient, timeout~ : Int, numkeys : String, keys : Array[String], where_~ : String) -> RedisValue

#
RedisClient::blpop

source
async fn RedisClient::blpop(self : RedisClient, keys : Array[String], timeout~ : Int) -> RedisValue

#
RedisClient::brpop

source
async fn RedisClient::brpop(self : RedisClient, keys : Array[String], timeout~ : Int) -> RedisValue

#
RedisClient::brpoplpush

source
async fn RedisClient::brpoplpush(self : RedisClient, source : String, destination : String, timeout~ : Int) -> RedisValue

#
RedisClient::bzmpop

source
async fn RedisClient::bzmpop(self : RedisClient, timeout : String, numkeys : String, keys : Array[String], where_ : String, count : String?) -> Result[Array[String], String]

#
RedisClient::bzpopmax

source
async fn RedisClient::bzpopmax(self : RedisClient, keys : Array[String], timeout : String) -> Result[String, String]

#
RedisClient::bzpopmin

source
async fn RedisClient::bzpopmin(self : RedisClient, keys : Array[String], timeout : String) -> Result[String, String]

#
RedisClient::client_caching

source
async fn RedisClient::client_caching(self : RedisClient, mode : String) -> Result[String, String]

#
RedisClient::client_getname

source
async fn RedisClient::client_getname(self : RedisClient) -> Result[String?, String]

#
RedisClient::client_getredir

source
async fn RedisClient::client_getredir(self : RedisClient) -> Result[Int, String]

#
RedisClient::client_id

source
async fn RedisClient::client_id(self : RedisClient) -> Result[Int, String]

#
RedisClient::client_info

source
async fn RedisClient::client_info(self : RedisClient) -> Result[String, String]

#
RedisClient::client_kill

source
async fn RedisClient::client_kill(self : RedisClient, ip_port : String) -> Result[Int, String]

#
RedisClient::client_list

source
async fn RedisClient::client_list(self : RedisClient) -> Result[String, String]

#
RedisClient::client_no_evict

source
async fn RedisClient::client_no_evict(self : RedisClient, mode : String) -> Result[String, String]

#
RedisClient::client_no_touch

source
async fn RedisClient::client_no_touch(self : RedisClient, mode : String) -> Result[String, String]

#
RedisClient::client_pause

source
async fn RedisClient::client_pause(self : RedisClient, timeout : String) -> Result[String, String]

#
RedisClient::client_reply

source
async fn RedisClient::client_reply(self : RedisClient, mode : String) -> Result[String, String]

#
RedisClient::client_setname

source
async fn RedisClient::client_setname(self : RedisClient, connection_name : String) -> Result[String, String]

#
RedisClient::client_tracking

source
async fn RedisClient::client_tracking(self : RedisClient, mode : String) -> Result[String, String]

#
RedisClient::client_trackinginfo

source
async fn RedisClient::client_trackinginfo(self : RedisClient) -> Result[Array[String], String]

#
RedisClient::client_unblock

source
async fn RedisClient::client_unblock(self : RedisClient, client_id : String) -> Result[Int, String]

#
RedisClient::client_unpause

source
async fn RedisClient::client_unpause(self : RedisClient) -> Result[String, String]

#
RedisClient::close

source
fn RedisClient::close(self : RedisClient) -> Unit

#
RedisClient::cluster_addslots

source
async fn RedisClient::cluster_addslots(self : RedisClient, slots : Array[Int]) -> Result[String, String]

#
RedisClient::cluster_addslotsrange

source
async fn RedisClient::cluster_addslotsrange(self : RedisClient, ranges : Array[(Int, Int)]) -> Result[String, String]

#
RedisClient::cluster_bumpepoch

source
async fn RedisClient::cluster_bumpepoch(self : RedisClient) -> Result[String, String]

#
RedisClient::cluster_count_failure_reports

source
async fn RedisClient::cluster_count_failure_reports(self : RedisClient, node_id : String) -> Result[Int, String]

#
RedisClient::cluster_countkeysinslot

source
async fn RedisClient::cluster_countkeysinslot(self : RedisClient, slot : Int) -> Result[Int, String]

#
RedisClient::cluster_delslots

source
async fn RedisClient::cluster_delslots(self : RedisClient, slots : Array[Int]) -> Result[String, String]

#
RedisClient::cluster_delslotsrange

source
async fn RedisClient::cluster_delslotsrange(self : RedisClient, ranges : Array[(Int, Int)]) -> Result[String, String]

#
RedisClient::cluster_failover

source
async fn RedisClient::cluster_failover(self : RedisClient, option? : String) -> Result[String, String]

#
RedisClient::cluster_flushslots

source
async fn RedisClient::cluster_flushslots(self : RedisClient) -> Result[String, String]

#
RedisClient::cluster_forget

source
async fn RedisClient::cluster_forget(self : RedisClient, node_id : String) -> Result[String, String]

#
RedisClient::cluster_getkeysinslot

source
async fn RedisClient::cluster_getkeysinslot(self : RedisClient, slot : Int, count : Int) -> Result[Array[String], String]

#
RedisClient::cluster_info

source
async fn RedisClient::cluster_info(self : RedisClient) -> Result[String, String]

#
RedisClient::cluster_keyslot

source
async fn RedisClient::cluster_keyslot(self : RedisClient, key : String) -> Result[Int, String]

async fn RedisClient::cluster_links(self : RedisClient) -> Result[Array[String], String]

#
RedisClient::cluster_meet

source
async fn RedisClient::cluster_meet(self : RedisClient, ip : String, port : Int, cluster_bus_port? : Int) -> Result[String, String]

#
RedisClient::cluster_myid

source
async fn RedisClient::cluster_myid(self : RedisClient) -> Result[String, String]

#
RedisClient::cluster_myshardid

source
async fn RedisClient::cluster_myshardid(self : RedisClient) -> Result[String, String]

#
RedisClient::cluster_nodes

source
async fn RedisClient::cluster_nodes(self : RedisClient) -> Result[String, String]

#
RedisClient::cluster_replicas

source
async fn RedisClient::cluster_replicas(self : RedisClient, node_id : String) -> Result[Array[String], String]

#
RedisClient::cluster_replicate

source
async fn RedisClient::cluster_replicate(self : RedisClient, node_id : String) -> Result[String, String]

#
RedisClient::cluster_reset

source
async fn RedisClient::cluster_reset(self : RedisClient, reset_type? : String) -> Result[String, String]

#
RedisClient::cluster_saveconfig

source
async fn RedisClient::cluster_saveconfig(self : RedisClient) -> Result[String, String]

#
RedisClient::cluster_set_config_epoch

source
async fn RedisClient::cluster_set_config_epoch(self : RedisClient, config_epoch : Int) -> Result[String, String]

#
RedisClient::cluster_setslot

source
async fn RedisClient::cluster_setslot(self : RedisClient, slot : Int, subcommand : String, node_id? : String) -> Result[String, String]

#
RedisClient::cluster_shards

source
async fn RedisClient::cluster_shards(self : RedisClient) -> Result[Array[String], String]

#
RedisClient::cluster_slaves

source
async fn RedisClient::cluster_slaves(self : RedisClient, node_id : String) -> Result[Array[String], String]

#
RedisClient::cluster_slot_stats

source
async fn RedisClient::cluster_slot_stats(self : RedisClient, slots : Array[Int]) -> Result[Array[String], String]

#
RedisClient::cluster_slots

source
async fn RedisClient::cluster_slots(self : RedisClient) -> Result[Array[String], String]

#
RedisClient::command

source
async fn RedisClient::command(self : RedisClient) -> RedisValue

#
RedisClient::command_count

source
async fn RedisClient::command_count(self : RedisClient) -> RedisValue

#
RedisClient::command_docs

source
async fn RedisClient::command_docs(self : RedisClient, command_names : Array[String]) -> RedisValue

#
RedisClient::command_getkeys

source
async fn RedisClient::command_getkeys(self : RedisClient, command : Array[String]) -> RedisValue

#
RedisClient::command_getkeysandflags

source
async fn RedisClient::command_getkeysandflags(self : RedisClient, command : Array[String]) -> RedisValue

#
RedisClient::command_info

source
async fn RedisClient::command_info(self : RedisClient, command_names : Array[String]) -> RedisValue

#
RedisClient::command_list

source
async fn RedisClient::command_list(self : RedisClient) -> RedisValue

#
RedisClient::config_get

source
async fn RedisClient::config_get(self : RedisClient, parameter : String) -> RedisValue

#
RedisClient::config_resetstat

source
async fn RedisClient::config_resetstat(self : RedisClient) -> RedisValue

#
RedisClient::config_rewrite

source
async fn RedisClient::config_rewrite(self : RedisClient) -> RedisValue

#
RedisClient::config_set

source
async fn RedisClient::config_set(self : RedisClient, parameter : String, value : String) -> RedisValue

#
RedisClient::copy

source
async fn RedisClient::copy(self : RedisClient, source : String, destination : String) -> Result[Int, String]

#
RedisClient::dbsize

source
async fn RedisClient::dbsize(self : RedisClient) -> Result[Int, String]

#
RedisClient::debug_object

source
async fn RedisClient::debug_object(self : RedisClient, key : String) -> RedisValue

#
RedisClient::debug_segfault

source
async fn RedisClient::debug_segfault(self : RedisClient) -> RedisValue

#
RedisClient::decr

source
async fn RedisClient::decr(self : RedisClient, key : String) -> Result[Int, String]

#
RedisClient::decrby

source
async fn RedisClient::decrby(self : RedisClient, key : String, decrement : String) -> Result[Int, String]

#
RedisClient::del

source
async fn RedisClient::del(self : RedisClient, keys : Array[String]) -> Result[Int, String]

#
RedisClient::dump

source
async fn RedisClient::dump(self : RedisClient, key : String) -> Result[String?, String]

#
RedisClient::echo

source
async fn RedisClient::echo(self : RedisClient, message : String) -> Result[String, String]

#
RedisClient::exists

source
async fn RedisClient::exists(self : RedisClient, keys : Array[String]) -> Result[Int, String]

#
RedisClient::expire

source
async fn RedisClient::expire(self : RedisClient, key : String, seconds : String) -> Result[Int, String]

#
RedisClient::expireat

source
async fn RedisClient::expireat(self : RedisClient, key : String, timestamp : String) -> Result[Int, String]

#
RedisClient::expiretime

source
async fn RedisClient::expiretime(self : RedisClient, key : String) -> Result[Int, String]

#
RedisClient::flushall

source
async fn RedisClient::flushall(self : RedisClient) -> Result[String, String]

#
RedisClient::flushdb

source
async fn RedisClient::flushdb(self : RedisClient) -> Result[String, String]

#
RedisClient::geoadd

source
async fn RedisClient::geoadd(self : RedisClient, key : String, longitude : String, latitude : String, value : String) -> Result[Int, String]

#
RedisClient::geoadd_multiple

source
async fn RedisClient::geoadd_multiple(self : RedisClient, key : String, coordinates : Array[GeoCoordinates]) -> Result[Int, String]

#
RedisClient::geodist

source
async fn RedisClient::geodist(self : RedisClient, key : String, member1 : String, member2 : String) -> Result[String?, String]

#
RedisClient::geodist_unit

source
async fn RedisClient::geodist_unit(self : RedisClient, key : String, member1 : String, member2 : String, unit : GeoUnits) -> Result[String?, String]

#
RedisClient::geohash

source
async fn RedisClient::geohash(self : RedisClient, key : String, members : Array[String]) -> Result[Array[String], String]

#
RedisClient::geopos

source
async fn RedisClient::geopos(self : RedisClient, key : String, members : Array[String]) -> Result[Array[String], String]

#
RedisClient::georadius

source
async fn RedisClient::georadius(self : RedisClient, key : String, longitude : String, latitude : String, radius : String, unit : GeoUnits) -> Result[Array[String], String]

#
RedisClient::georadius_ro

source
async fn RedisClient::georadius_ro(self : RedisClient, key : String, longitude : String, latitude : String, radius : String, unit : GeoUnits) -> Result[Array[String], String]

#
RedisClient::georadiusbymember

source
async fn RedisClient::georadiusbymember(self : RedisClient, key : String, value : String, radius : String, unit : GeoUnits) -> Result[Array[String], String]

#
RedisClient::georadiusbymember_ro

source
async fn RedisClient::georadiusbymember_ro(self : RedisClient, key : String, value : String, radius : String, unit : GeoUnits) -> Result[Array[String], String]

#
RedisClient::geosearch

source
async fn RedisClient::geosearch(self : RedisClient, key : String, member_ : String, radius : String, unit : GeoUnits) -> Result[Array[String], String]

#
RedisClient::geosearch_box

source
async fn RedisClient::geosearch_box(self : RedisClient, key : String, coordinates : GeoCoordinates, search_box : GeoSearchByBox) -> Result[Array[String], String]

#
RedisClient::geosearch_with_dist

source
async fn RedisClient::geosearch_with_dist(self : RedisClient, key : String, member_ : String, radius : Double, unit : GeoUnits) -> Result[Array[String], String]

#
RedisClient::geosearchstore

source
async fn RedisClient::geosearchstore(self : RedisClient, source : String, destination : String, member_ : String, radius : String, unit : GeoUnits) -> Result[Int, String]

#
RedisClient::geosearchstore_box

source
async fn RedisClient::geosearchstore_box(self : RedisClient, destination : String, source : String, from_member : String, search_box : GeoSearchByBox) -> Result[Int, String]

#
RedisClient::geosearchstore_with_dist

source
async fn RedisClient::geosearchstore_with_dist(self : RedisClient, destination : String, source : String, member_ : String, radius : Double, unit : GeoUnits) -> Result[Int, String]

#
RedisClient::get

source
async fn RedisClient::get(self : RedisClient, key : String) -> Result[String, String]

#
RedisClient::getbit

source
async fn RedisClient::getbit(self : RedisClient, key : String, offset : Int) -> Result[Int, String]

#
RedisClient::getdel

source
async fn RedisClient::getdel(self : RedisClient, key : String) -> Result[String, String]

#
RedisClient::getex

source
async fn RedisClient::getex(self : RedisClient, key : String, ex : String) -> Result[String, String]

#
RedisClient::getrange

source
async fn RedisClient::getrange(self : RedisClient, key : String, start : String, end : String) -> Result[String, String]

#
RedisClient::getset

source
async fn RedisClient::getset(self : RedisClient, key : String, value : String) -> Result[String, String]

#
RedisClient::hdel

source
async fn RedisClient::hdel(self : RedisClient, key : String, fields : Array[String]) -> Result[Int, String]

#
RedisClient::hello

source
async fn RedisClient::hello(self : RedisClient, protover : String) -> Result[Array[String], String]

#
RedisClient::hexists

source
async fn RedisClient::hexists(self : RedisClient, key : String, field : String) -> Result[Bool, String]

#
RedisClient::hget

source
async fn RedisClient::hget(self : RedisClient, key : String, field : String) -> Result[String, String]

#
RedisClient::hgetall

source
async fn RedisClient::hgetall(self : RedisClient, key : String) -> Result[Map[String, String], String]

#
RedisClient::hkeys

source
async fn RedisClient::hkeys(self : RedisClient, key : String) -> Result[Array[String], String]

#
RedisClient::hlen

source
async fn RedisClient::hlen(self : RedisClient, key : String) -> Result[Int, String]

#
RedisClient::hset

source
async fn RedisClient::hset(self : RedisClient, key : String, field : String, value : String) -> Result[Int, String]

#
RedisClient::hvals

source
async fn RedisClient::hvals(self : RedisClient, key : String) -> Result[Array[String], String]

#
RedisClient::incr

source
async fn RedisClient::incr(self : RedisClient, key : String) -> Result[Int, String]

#
RedisClient::incrby

source
async fn RedisClient::incrby(self : RedisClient, key : String, increment : String) -> Result[Int, String]

#
RedisClient::incrbyfloat

source
async fn RedisClient::incrbyfloat(self : RedisClient, key : String, increment : String) -> Result[String, String]

#
RedisClient::info

source
async fn RedisClient::info(self : RedisClient) -> RedisValue

#
RedisClient::info_section

source
async fn RedisClient::info_section(self : RedisClient, section : String) -> RedisValue

#
RedisClient::json_arrappend

source
async fn RedisClient::json_arrappend(self : RedisClient, key : String, path : String, values : Array[String]) -> Result[Int, String]

JSON.ARRAPPEND - 向JSON数组追加元素

#
RedisClient::json_arrinsert

source
async fn RedisClient::json_arrinsert(self : RedisClient, key : String, path : String, index : Int, values : Array[String]) -> Result[Int, String]

JSON.ARRINSERT - 在JSON数组指定位置插入元素

#
RedisClient::json_arrlen

source
async fn RedisClient::json_arrlen(self : RedisClient, key : String, path : String) -> Result[Int, String]

JSON.ARRLEN - 获取JSON数组长度

#
RedisClient::json_arrpop

source
async fn RedisClient::json_arrpop(self : RedisClient, key : String, path : String, index : Int) -> Result[String, String]

JSON.ARRPOP - 从JSON数组弹出元素

#
RedisClient::json_arrtrim

source
async fn RedisClient::json_arrtrim(self : RedisClient, key : String, path : String, start : Int, stop : Int) -> Result[Int, String]

JSON.ARRTRIM - 修剪JSON数组

#
RedisClient::json_clear

source
async fn RedisClient::json_clear(self : RedisClient, key : String, path : String) -> Result[Int, String]

JSON.CLEAR - 清空JSON值

#
RedisClient::json_debug

source
async fn RedisClient::json_debug(self : RedisClient, subcommand : String, key : String, path : String) -> Result[String, String]

JSON.DEBUG - JSON调试命令

#
RedisClient::json_del

source
async fn RedisClient::json_del(self : RedisClient, key : String, path : String) -> Result[Int, String]

JSON.DEL - 删除JSON路径

#
RedisClient::json_forget

source
async fn RedisClient::json_forget(self : RedisClient, key : String, path : String) -> Result[Int, String]

JSON.FORGET - 删除JSON路径（JSON.DEL的别名）

#
RedisClient::json_get

source
async fn RedisClient::json_get(self : RedisClient, key : String, path : String) -> Result[Json, String]

JSON.GET - 获取JSON值

#
RedisClient::json_numincrby

source
async fn RedisClient::json_numincrby(self : RedisClient, key : String, path : String, value : String) -> Result[String, String]

JSON.NUMINCRBY - 对JSON数值进行增量操作

#
RedisClient::json_nummultby

source
async fn RedisClient::json_nummultby(self : RedisClient, key : String, path : String, value : String) -> Result[String, String]

JSON.NUMMULTBY - 对JSON数值进行乘法操作

#
RedisClient::json_objkeys

source
async fn RedisClient::json_objkeys(self : RedisClient, key : String, path : String) -> Result[Array[String], String]

JSON.OBJKEYS - 获取JSON对象的键

#
RedisClient::json_objlen

source
async fn RedisClient::json_objlen(self : RedisClient, key : String, path : String) -> Result[Int, String]

JSON.OBJLEN - 获取JSON对象的键数量

#
RedisClient::json_resp

source
async fn RedisClient::json_resp(self : RedisClient, key : String, path : String) -> Result[Array[String], String]

JSON.RESP - 以RESP格式返回JSON值

#
RedisClient::json_set

source
async fn RedisClient::json_set(self : RedisClient, key : String, path : String, value : String) -> Result[Json, String]

JSON.SET - 设置JSON值

#
RedisClient::json_strappend

source
async fn RedisClient::json_strappend(self : RedisClient, key : String, path : String, value : String) -> Result[Int, String]

JSON.STRAPPEND - 向JSON字符串追加内容

#
RedisClient::json_strlen

source
async fn RedisClient::json_strlen(self : RedisClient, key : String, path : String) -> Result[Int, String]

JSON.STRLEN - 获取JSON字符串长度

#
RedisClient::json_toggle

source
async fn RedisClient::json_toggle(self : RedisClient, key : String, path : String) -> Result[Int, String]

JSON.TOGGLE - 切换JSON布尔值

#
RedisClient::json_type

source
async fn RedisClient::json_type(self : RedisClient, key : String, path : String) -> Result[String, String]

JSON.TYPE - 获取JSON值类型

#
RedisClient::keys

source
async fn RedisClient::keys(self : RedisClient, pattern : String) -> Result[Array[String], String]

#
RedisClient::lastsave

source
async fn RedisClient::lastsave(self : RedisClient) -> RedisValue

#
RedisClient::latency_doctor

source
async fn RedisClient::latency_doctor(self : RedisClient) -> RedisValue

#
RedisClient::latency_graph

source
async fn RedisClient::latency_graph(self : RedisClient, event : String) -> RedisValue

#
RedisClient::latency_history

source
async fn RedisClient::latency_history(self : RedisClient, event : String) -> RedisValue

#
RedisClient::latency_latest

source
async fn RedisClient::latency_latest(self : RedisClient) -> RedisValue

#
RedisClient::latency_reset

source
async fn RedisClient::latency_reset(self : RedisClient, events : Array[String]) -> RedisValue

#
RedisClient::lindex

source
async fn RedisClient::lindex(self : RedisClient, key : String, index~ : Int) -> Result[String, String]

#
RedisClient::linsert

source
async fn RedisClient::linsert(self : RedisClient, key : String, where_~ : String, pivot~ : String, element~ : String) -> Result[Int, String]

#
RedisClient::llen

source
async fn RedisClient::llen(self : RedisClient, key : String) -> Result[Int, String]

#
RedisClient::lmove

source
async fn RedisClient::lmove(self : RedisClient, source : String, destination : String, wherefrom~ : Int, whereto~ : Int) -> RedisValue

#
RedisClient::lmpop

source
async fn RedisClient::lmpop(self : RedisClient, numkeys : String, keys : Array[String], where_~ : String) -> RedisValue

#
RedisClient::lpop

source
async fn RedisClient::lpop(self : RedisClient, key : String) -> Result[String, String]

#
RedisClient::lpos

source
async fn RedisClient::lpos(self : RedisClient, key : String, element~ : String) -> RedisValue

#
RedisClient::lpush

source
async fn RedisClient::lpush(self : RedisClient, key : String, values : Array[String]) -> Result[Int, String]

#
RedisClient::lpushx

source
async fn RedisClient::lpushx(self : RedisClient, key : String, values : Array[String]) -> Result[Int, String]

#
RedisClient::lrange

source
async fn RedisClient::lrange(self : RedisClient, key : String, start~ : Int, stop~ : Int) -> Result[Array[String], String]

#
RedisClient::lrem

source
async fn RedisClient::lrem(self : RedisClient, key : String, count~ : Int, value~ : String) -> Result[Int, String]

#
RedisClient::lset

source
async fn RedisClient::lset(self : RedisClient, key : String, index~ : Int, value~ : String) -> Result[String, String]

#
RedisClient::ltrim

source
async fn RedisClient::ltrim(self : RedisClient, key : String, start~ : Int, stop~ : Int) -> Result[String, String]

#
RedisClient::memory_doctor

source
async fn RedisClient::memory_doctor(self : RedisClient) -> RedisValue

#
RedisClient::memory_malloc_stats

source
async fn RedisClient::memory_malloc_stats(self : RedisClient) -> RedisValue

#
RedisClient::memory_purge

source
async fn RedisClient::memory_purge(self : RedisClient) -> RedisValue

#
RedisClient::memory_stats

source
async fn RedisClient::memory_stats(self : RedisClient) -> RedisValue

#
RedisClient::memory_usage

source
async fn RedisClient::memory_usage(self : RedisClient, key : String) -> RedisValue

#
RedisClient::mget

source
async fn RedisClient::mget(self : RedisClient, keys : Array[String]) -> Result[Array[String], String]

#
RedisClient::migrate

source
async fn RedisClient::migrate(self : RedisClient, host : String, port : String, key : String, destination_db : String, timeout : String) -> Result[String, String]

#
RedisClient::module_list

source
async fn RedisClient::module_list(self : RedisClient) -> RedisValue

#
RedisClient::module_load

source
async fn RedisClient::module_load(self : RedisClient, path : String) -> RedisValue

#
RedisClient::module_loadex

source
async fn RedisClient::module_loadex(self : RedisClient, path : String, args : Array[String]) -> RedisValue

#
RedisClient::module_unload

source
async fn RedisClient::module_unload(self : RedisClient, name : String) -> RedisValue

#
RedisClient::monitor

source
async fn RedisClient::monitor(self : RedisClient) -> RedisValue

#
RedisClient::move_

source
async fn RedisClient::move_(self : RedisClient, key : String, db : String) -> Result[Int, String]

#
RedisClient::mset

source
async fn RedisClient::mset(self : RedisClient, key_values : Map[String, String]) -> Result[String, String]

#
RedisClient::msetnx

source
async fn RedisClient::msetnx(self : RedisClient, key_values : Map[String, String]) -> Result[Int, String]

#
RedisClient::object_encoding

source
async fn RedisClient::object_encoding(self : RedisClient, key : String) -> Result[String?, String]

#
RedisClient::object_freq

source
async fn RedisClient::object_freq(self : RedisClient, key : String) -> Result[Int, String]

#
RedisClient::object_idletime

source
async fn RedisClient::object_idletime(self : RedisClient, key : String) -> Result[Int, String]

#
RedisClient::object_refcount

source
async fn RedisClient::object_refcount(self : RedisClient, key : String) -> Result[Int, String]

#
RedisClient::persist

source
async fn RedisClient::persist(self : RedisClient, key : String) -> Result[Int, String]

#
RedisClient::pexpire

source
async fn RedisClient::pexpire(self : RedisClient, key : String, milliseconds : String) -> Result[Int, String]

#
RedisClient::pexpireat

source
async fn RedisClient::pexpireat(self : RedisClient, key : String, timestamp : String) -> Result[Int, String]

#
RedisClient::pexpiretime

source
async fn RedisClient::pexpiretime(self : RedisClient, key : String) -> Result[Int, String]

#
RedisClient::ping

source
async fn RedisClient::ping(self : RedisClient) -> Result[String, String]

#
RedisClient::psetex

source
async fn RedisClient::psetex(self : RedisClient, key : String, milliseconds : String, value : String) -> Result[String, String]

#
RedisClient::psubscribe

source
async fn RedisClient::psubscribe(self : RedisClient, patterns : Array[String]) -> Result[Array[String], String]

订阅一个或多个模式 返回模式订阅确认信息数组

#
RedisClient::psync

source
async fn RedisClient::psync(self : RedisClient, replicationid : String, offset : String) -> RedisValue

#
RedisClient::pttl

source
async fn RedisClient::pttl(self : RedisClient, key : String) -> Result[Int, String]

#
RedisClient::publish

source
async fn RedisClient::publish(self : RedisClient, channel : String, message : String) -> Result[Int, String]

发布消息到指定频道 返回接收到消息的订阅者数量

#
RedisClient::pubsub_channels

source
async fn RedisClient::pubsub_channels(self : RedisClient, pattern? : String) -> Result[Array[String], String]

查看订阅与发布系统状态 PUBSUB CHANNELS [pattern] - 列出当前活跃频道

#
RedisClient::pubsub_numpat

source
async fn RedisClient::pubsub_numpat(self : RedisClient) -> Result[Int, String]

查看订阅与发布系统状态 PUBSUB NUMPAT - 返回模式订阅数量

#
RedisClient::pubsub_numsub

source
async fn RedisClient::pubsub_numsub(self : RedisClient, channels? : Array[String]) -> Result[Array[String], String]

查看订阅与发布系统状态 PUBSUB NUMSUB [channel [channel ...]] - 返回频道订阅者数量

#
RedisClient::pubsub_shardchannels

source
async fn RedisClient::pubsub_shardchannels(self : RedisClient, pattern? : String) -> Result[Array[String], String]

查看订阅与发布系统状态 PUBSUB SHARDCHANNELS [pattern] - 列出分片频道

#
RedisClient::pubsub_shardnumsub

source
async fn RedisClient::pubsub_shardnumsub(self : RedisClient, channels? : Array[String]) -> Result[Array[String], String]

查看订阅与发布系统状态 PUBSUB SHARDNUMSUB [channel [channel ...]] - 返回分片频道订阅者数量

#
RedisClient::punsubscribe

source
async fn RedisClient::punsubscribe(self : RedisClient, patterns? : Array[String]) -> Result[Array[String], String]

取消订阅模式 如果不指定模式，则取消所有模式订阅

#
RedisClient::quit

source
async fn RedisClient::quit(self : RedisClient) -> Result[String, String]

#
RedisClient::randomkey

source
async fn RedisClient::randomkey(self : RedisClient) -> Result[String?, String]

#
RedisClient::read

source
async fn RedisClient::read(self : RedisClient, buf : FixedArray[Byte]) -> Int

#
RedisClient::read_redis_value

source
async fn RedisClient::read_redis_value(self : RedisClient) -> RedisValue

读取Redis响应并解析为RedisValue类型

#
RedisClient::read_response

source
async fn RedisClient::read_response(self : RedisClient) -> String

#
RedisClient::rename

source
async fn RedisClient::rename(self : RedisClient, key : String, newkey : String) -> Result[String, String]

#
RedisClient::renamenx

source
async fn RedisClient::renamenx(self : RedisClient, key : String, newkey : String) -> Result[Int, String]

#
RedisClient::replconf

source
async fn RedisClient::replconf(self : RedisClient, option : String, value : String) -> RedisValue

#
RedisClient::replicaof

source
async fn RedisClient::replicaof(self : RedisClient, host : String, port : String) -> RedisValue

#
RedisClient::reset

source
async fn RedisClient::reset(self : RedisClient) -> Result[String, String]

#
RedisClient::restore

source
async fn RedisClient::restore(self : RedisClient, key : String, ttl : String, serialized_value : String) -> Result[String, String]

#
RedisClient::role

source
async fn RedisClient::role(self : RedisClient) -> RedisValue

#
RedisClient::rpop

source
async fn RedisClient::rpop(self : RedisClient, key : String) -> Result[String, String]

#
RedisClient::rpoplpush

source
async fn RedisClient::rpoplpush(self : RedisClient, source : String, destination : String) -> RedisValue

#
RedisClient::rpush

source
async fn RedisClient::rpush(self : RedisClient, key : String, values : Array[String]) -> Result[Int, String]

#
RedisClient::rpushx

source
async fn RedisClient::rpushx(self : RedisClient, key : String, values : Array[String]) -> Result[Int, String]

#
RedisClient::sadd

source
async fn RedisClient::sadd(self : RedisClient, key : String, members : Array[String]) -> Result[Int, String]

#
RedisClient::save

source
async fn RedisClient::save(self : RedisClient) -> RedisValue

#
RedisClient::scan

source
async fn RedisClient::scan(self : RedisClient, cursor : String) -> Result[Array[String], String]

#
RedisClient::scard

source
async fn RedisClient::scard(self : RedisClient, key : String) -> Result[Int, String]

#
RedisClient::sdiff

source
async fn RedisClient::sdiff(self : RedisClient, keys : Array[String]) -> Result[Array[String], String]

#
RedisClient::sdiffstore

source
async fn RedisClient::sdiffstore(self : RedisClient, destination : String, keys : Array[String]) -> Result[Int, String]

#
RedisClient::select

source
async fn RedisClient::select(self : RedisClient, index : String) -> Result[String, String]

#
RedisClient::send

source
async fn RedisClient::send(self : RedisClient, args : Array[String]) -> RedisValue

#
RedisClient::set

source
async fn RedisClient::set(self : RedisClient, key : String, value : String, condition? : SetCondition, get? : Bool, expiration? : SetExpiration) -> Result[String, String]

基本的 SET 命令

#
RedisClient::setbit

source
async fn RedisClient::setbit(self : RedisClient, key : String, offset : Int, value : Bit) -> Result[Int, String]

#
RedisClient::setex

source
async fn RedisClient::setex(self : RedisClient, key : String, seconds : String, value : String) -> Result[String, String]

#
RedisClient::setnx

source
async fn RedisClient::setnx(self : RedisClient, key : String, value : String) -> Result[Int, String]

#
RedisClient::setrange

source
async fn RedisClient::setrange(self : RedisClient, key : String, offset : String, value : String) -> Result[Int, String]

#
RedisClient::shutdown

source
async fn RedisClient::shutdown(self : RedisClient) -> RedisValue

#
RedisClient::sinter

source
async fn RedisClient::sinter(self : RedisClient, keys : Array[String]) -> Result[Int, String]

#
RedisClient::sintercard

source
async fn RedisClient::sintercard(self : RedisClient, numkeys : String, keys : Array[String]) -> Result[Int, String]

#
RedisClient::sinterstore

source
async fn RedisClient::sinterstore(self : RedisClient, destination : String, keys : Array[String]) -> Result[Int, String]

#
RedisClient::sismember

source
async fn RedisClient::sismember(self : RedisClient, key : String, value : String) -> Result[Int, String]

#
RedisClient::slaveof

source
async fn RedisClient::slaveof(self : RedisClient, host : String, port : String) -> RedisValue

#
RedisClient::slowlog_get

source
async fn RedisClient::slowlog_get(self : RedisClient) -> RedisValue

#
RedisClient::slowlog_len

source
async fn RedisClient::slowlog_len(self : RedisClient) -> RedisValue

#
RedisClient::slowlog_reset

source
async fn RedisClient::slowlog_reset(self : RedisClient) -> RedisValue

#
RedisClient::smembers

source
async fn RedisClient::smembers(self : RedisClient, key : String) -> Result[Array[String], String]

#
RedisClient::smismember

source
async fn RedisClient::smismember(self : RedisClient, key : String, members : Array[String]) -> Result[Array[String], String]

#
RedisClient::smove

source
async fn RedisClient::smove(self : RedisClient, source : String, destination : String, value : String) -> Result[Int, String]

#
RedisClient::sort

source
async fn RedisClient::sort(self : RedisClient, key : String) -> Result[Array[String], String]

#
RedisClient::sort_ro

source
async fn RedisClient::sort_ro(self : RedisClient, key : String) -> Result[Array[String], String]

#
RedisClient::spop

source
async fn RedisClient::spop(self : RedisClient, key : String) -> Result[String, String]

#
RedisClient::spublish

source
async fn RedisClient::spublish(self : RedisClient, channel : String, message : String) -> Result[Int, String]

发布消息到分片频道 返回接收到消息的订阅者数量

#
RedisClient::srandmember

source
async fn RedisClient::srandmember(self : RedisClient, key : String) -> Result[String, String]

#
RedisClient::srem

source
async fn RedisClient::srem(self : RedisClient, key : String, members : Array[String]) -> Result[Int, String]

#
RedisClient::sscan

source
async fn RedisClient::sscan(self : RedisClient, key : String, cursor : Int, match_pattern? : String, count? : Int) -> Result[Array[String], String]

#
RedisClient::ssubscribe

source
async fn RedisClient::ssubscribe(self : RedisClient, channels : Array[String]) -> Result[Array[String], String]

订阅分片频道 返回订阅确认信息数组

#
RedisClient::strlen

source
async fn RedisClient::strlen(self : RedisClient, key : String) -> Result[Int, String]

#
RedisClient::subscribe

source
async fn RedisClient::subscribe(self : RedisClient, channels : Array[String]) -> Result[Array[String], String]

订阅一个或多个频道 返回订阅确认信息数组

#
RedisClient::substr

source
async fn RedisClient::substr(self : RedisClient, key : String, start : Int, end : Int) -> Result[String, String]

#
RedisClient::sunion

source
async fn RedisClient::sunion(self : RedisClient, keys : Array[String]) -> Result[Int, String]

#
RedisClient::sunionstore

source
async fn RedisClient::sunionstore(self : RedisClient, destination : String, keys : Array[String]) -> Result[Int, String]

#
RedisClient::sunsubscribe

source
async fn RedisClient::sunsubscribe(self : RedisClient, channels? : Array[String]) -> Result[Array[String], String]

取消订阅分片频道 如果不指定频道，则取消所有分片频道订阅

#
RedisClient::swapdb

source
async fn RedisClient::swapdb(self : RedisClient, index1 : String, index2 : String) -> Result[String, String]

#
RedisClient::sync

source
async fn RedisClient::sync(self : RedisClient) -> RedisValue

#
RedisClient::time

source
async fn RedisClient::time(self : RedisClient) -> RedisValue

#
RedisClient::touch

source
async fn RedisClient::touch(self : RedisClient, keys : Array[String]) -> Result[Int, String]

#
RedisClient::ttl

source
async fn RedisClient::ttl(self : RedisClient, key : String) -> Result[Int, String]

#
RedisClient::type_

source
async fn RedisClient::type_(self : RedisClient, key : String) -> Result[String, String]

async fn RedisClient::unlink(self : RedisClient, keys : Array[String]) -> Result[Int, String]

#
RedisClient::unsubscribe

source
async fn RedisClient::unsubscribe(self : RedisClient, channels? : Array[String]) -> Result[Array[String], String]

取消订阅频道 如果不指定频道，则取消所有订阅

#
RedisClient::wait

source
async fn RedisClient::wait(self : RedisClient, numreplicas : String, timeout : String) -> Result[Int, String]

#
RedisClient::waitaof

source
async fn RedisClient::waitaof(self : RedisClient, numlocal : String, numreplicas : String, timeout : String) -> Result[Int, String]

#
RedisClient::write

source
async fn RedisClient::write(self : RedisClient, data : String) -> Unit

#
RedisClient::xack

source
async fn RedisClient::xack(self : RedisClient, key : String, group : String, ids : Array[String]) -> Result[Int, String]

确认消息

#
RedisClient::xadd

source
async fn RedisClient::xadd(self : RedisClient, key : String, id : String, field_values : Map[String, String]) -> Result[String, String]

添加条目到流

#
RedisClient::xautoclaim

source
async fn RedisClient::xautoclaim(self : RedisClient, key : String, group : String, consumer : String, min_idle_time : Int, start~ : String, count? : Int) -> Result[Array[String], String]

自动声明消息

#
RedisClient::xclaim

source
async fn RedisClient::xclaim(self : RedisClient, key : String, group : String, consumer : String, min_idle_time : Int, ids : Array[String]) -> Result[Array[String], String]

声明消息

#
RedisClient::xdel

source
async fn RedisClient::xdel(self : RedisClient, key : String, ids : Array[String]) -> Result[Int, String]

删除流条目

#
RedisClient::xgroup_create

source
async fn RedisClient::xgroup_create(self : RedisClient, key : String, group : String, id : String, mkstream : Bool) -> Result[String, String]

创建消费者组

#
RedisClient::xgroup_createconsumer

source
async fn RedisClient::xgroup_createconsumer(self : RedisClient, key : String, group : String, consumer : String) -> Result[Int, String]

创建消费者

#
RedisClient::xgroup_delconsumer

source
async fn RedisClient::xgroup_delconsumer(self : RedisClient, key : String, group : String, consumer : String) -> Result[Int, String]

删除消费者

#
RedisClient::xgroup_destroy

source
async fn RedisClient::xgroup_destroy(self : RedisClient, key : String, group : String) -> Result[Int, String]

销毁消费者组

#
RedisClient::xgroup_setid

source
async fn RedisClient::xgroup_setid(self : RedisClient, key : String, group : String, id : String) -> Result[String, String]

设置消费者组ID

#
RedisClient::xinfo_consumers

source
async fn RedisClient::xinfo_consumers(self : RedisClient, key : String, group : String) -> Result[Array[String], String]

获取消费者信息

#
RedisClient::xinfo_groups

source
async fn RedisClient::xinfo_groups(self : RedisClient, key : String) -> Result[Array[String], String]

获取消费者组信息

#
RedisClient::xinfo_stream

source
async fn RedisClient::xinfo_stream(self : RedisClient, key : String) -> Result[Array[String], String]

获取流信息

#
RedisClient::xlen

source
async fn RedisClient::xlen(self : RedisClient, key : String) -> Result[Int, String]

获取流长度

#
RedisClient::xpending

source
async fn RedisClient::xpending(self : RedisClient, key : String, group : String) -> Result[Array[String], String]

查看待处理消息

#
RedisClient::xpending_range

source
async fn RedisClient::xpending_range(self : RedisClient, key : String, group : String, start~ : String, end~ : String, count~ : Int, consumer? : String) -> Result[Array[String], String]

查看待处理消息详情

#
RedisClient::xrange

source
async fn RedisClient::xrange(self : RedisClient, key : String, start~ : String, end~ : String, count? : Int) -> Result[Array[RedisStreamMessage], String]

范围查询流条目

#
RedisClient::xread

source
async fn RedisClient::xread(self : RedisClient, count? : Int, block? : Int, streams : Array[(String, String)]) -> Result[RedisStream, String]

读取流条目

#
RedisClient::xreadgroup

source
async fn RedisClient::xreadgroup(self : RedisClient, group : String, consumer : String, count? : Int, block? : Int, noack? : Bool, streams : Array[(String, String)]) -> Result[RedisStream, String]

消费者组读取

#
RedisClient::xrevrange

source
async fn RedisClient::xrevrange(self : RedisClient, key : String, end~ : String, start~ : String, count? : Int) -> Result[Array[RedisStreamMessage], String]

反向范围查询流条目

#
RedisClient::xtrim

source
async fn RedisClient::xtrim(self : RedisClient, key : String, strategy~ : XTrimStrategy, threshold~ : Int64, approximate? : Bool, limit? : Int, keepref? : Bool, delref? : Bool, acked? : Bool) -> Result[Int, String]

修剪流

#
RedisClient::zadd

source
async fn RedisClient::zadd(self : RedisClient, key : String, zadd_members : Array[ZAddMember]) -> Result[Int, String]

#
RedisClient::zcard

source
async fn RedisClient::zcard(self : RedisClient, key : String) -> Result[Int, String]

#
RedisClient::zcount

source
async fn RedisClient::zcount(self : RedisClient, key : String, min~ : String, max~ : String) -> Result[Int, String]

#
RedisClient::zdiff

source
async fn RedisClient::zdiff(self : RedisClient, numkeys : String, keys : Array[String]) -> Result[Array[String], String]

#
RedisClient::zdiffstore

source
async fn RedisClient::zdiffstore(self : RedisClient, destination : String, numkeys : String, keys : Array[String]) -> Result[Int, String]

#
RedisClient::zincrby

source
async fn RedisClient::zincrby(self : RedisClient, key : String, increment~ : String, value~ : String) -> Result[String, String]

#
RedisClient::zinter

source
async fn RedisClient::zinter(self : RedisClient, numkeys : String, keys : Array[String]) -> Result[Array[String], String]

#
RedisClient::zintercard

source
async fn RedisClient::zintercard(self : RedisClient, numkeys : String, keys : Array[String]) -> Result[Int, String]

#
RedisClient::zinterstore

source
async fn RedisClient::zinterstore(self : RedisClient, destination : String, numkeys : String, keys : Array[String]) -> Result[Int, String]

#
RedisClient::zlexcount

source
async fn RedisClient::zlexcount(self : RedisClient, key : String, min~ : String, max~ : String) -> Result[Int, String]

#
RedisClient::zmpop

source
async fn RedisClient::zmpop(self : RedisClient, numkeys : String, keys : Array[String], value : String) -> Result[Array[String], String]

#
RedisClient::zmscore

source
async fn RedisClient::zmscore(self : RedisClient, key : String, members : Array[String]) -> Result[Array[String], String]

#
RedisClient::zpopmax

source
async fn RedisClient::zpopmax(self : RedisClient, key : String) -> Result[String, String]

#
RedisClient::zpopmin

source
async fn RedisClient::zpopmin(self : RedisClient, key : String) -> Result[String, String]

#
RedisClient::zrandmember

source
async fn RedisClient::zrandmember(self : RedisClient, key : String) -> Result[String, String]

#
RedisClient::zrange

source
async fn RedisClient::zrange(self : RedisClient, key : String, start~ : String, stop~ : String) -> Result[Array[String], String]

#
RedisClient::zrangebylex

source
async fn RedisClient::zrangebylex(self : RedisClient, key : String, min~ : String, max~ : String) -> Result[Array[String], String]

#
RedisClient::zrangebyscore

source
async fn RedisClient::zrangebyscore(self : RedisClient, key : String, min~ : String, max~ : String) -> Result[Array[String], String]

#
RedisClient::zrangestore

source
async fn RedisClient::zrangestore(self : RedisClient, dst : String, src : String, min~ : String, max~ : String) -> Result[Int, String]

#
RedisClient::zrank

source
async fn RedisClient::zrank(self : RedisClient, key : String, value : String) -> Result[Int, String]

#
RedisClient::zrem

source
async fn RedisClient::zrem(self : RedisClient, key : String, members : Array[String]) -> Result[Int, String]

#
RedisClient::zremrangebylex

source
async fn RedisClient::zremrangebylex(self : RedisClient, key : String, min : String, max : String) -> Result[Int, String]

#
RedisClient::zremrangebyrank

source
async fn RedisClient::zremrangebyrank(self : RedisClient, key : String, start : String, stop : String) -> Result[Int, String]

#
RedisClient::zremrangebyscore

source
async fn RedisClient::zremrangebyscore(self : RedisClient, key : String, min : String, max : String) -> Result[Int, String]

#
RedisClient::zrevrange

source
async fn RedisClient::zrevrange(self : RedisClient, key : String, start~ : String, stop~ : String) -> Result[Array[String], String]

#
RedisClient::zrevrangebylex

source
async fn RedisClient::zrevrangebylex(self : RedisClient, key : String, max~ : String, min~ : String) -> Result[Array[String], String]

#
RedisClient::zrevrangebyscore

source
async fn RedisClient::zrevrangebyscore(self : RedisClient, key : String, max~ : String, min~ : String) -> Result[Array[String], String]

#
RedisClient::zrevrank

source
async fn RedisClient::zrevrank(self : RedisClient, key : String, value : String) -> Result[Int, String]

#
RedisClient::zscan

source
async fn RedisClient::zscan(self : RedisClient, key : String, cursor : String) -> Result[Array[String], String]

#
RedisClient::zscore

source
async fn RedisClient::zscore(self : RedisClient, key : String, value : String) -> Result[String, String]

#
RedisClient::zunion

source
async fn RedisClient::zunion(self : RedisClient, numkeys : String, keys : Array[String]) -> Result[Array[String], String]

#
RedisClient::zunionstore

source
async fn RedisClient::zunionstore(self : RedisClient, destination : String, numkeys : String, keys : Array[String]) -> Result[Int, String]

#
RedisStream

source
pub(all) struct RedisStream {
  name : String
  messages : Array[RedisStreamMessage]
} derive(
Debug)

impl Show for RedisStream

#
RedisStreamMessage

source
pub(all) struct RedisStreamMessage {
  id : String
  fields : Array[String]
} derive(
Debug)

#
RedisValue

source
pub(all) enum RedisValue {
  SimpleString(String)
  Error(String)
  Integer(Int)
  BulkString(String?)
  Array(Array[RedisValue])
} derive(Eq, Hash, 
Debug)

Redis响应的基本类型
impl Show for RedisValue

#
RedisValue::to_array

source
fn RedisValue::to_array(self : RedisValue) -> Result[Array[String], String]

将RedisValue转换为数组

#
RedisValue::to_bool

source
fn RedisValue::to_bool(self : RedisValue) -> Result[Bool, String]

将RedisValue转换为布尔值

#
RedisValue::to_bulk_string

source
fn RedisValue::to_bulk_string(self : RedisValue) -> Result[String?, String]

将RedisValue转换为具体类型

#
RedisValue::to_int

source
fn RedisValue::to_int(self : RedisValue) -> Result[Int, String]

将RedisValue转换为整数

#
RedisValue::to_json

source
fn RedisValue::to_json(self : RedisValue) -> Result[Json, String]

将RedisValue转换为JSON

#
RedisValue::to_stream

source
fn RedisValue::to_stream(self : RedisValue) -> Result[RedisStream, String]

#
RedisValue::to_stream_message_array

source
fn RedisValue::to_stream_message_array(self : RedisValue) -> Result[Array[RedisStreamMessage], String]

将RedisValue转换为Stream消息数组（用于XRANGE等命令）

#
RedisValue::to_string

source
fn RedisValue::to_string(self : RedisValue) -> Result[String, String]

将RedisValue转换为具体类型

#
SetCondition

source
pub(all) enum SetCondition {
  NX
  XX
  IFEQ(String)
}

SET 命令的条件选项

#
SetExpiration

source
pub(all) enum SetExpiration {
  EX(Int)
  PX(Int)
  EXAT(Int)
  PXAT(Int)
  KEEPTTL
}

SET 命令的过期时间选项

#
XTrimStrategy

source
pub(all) enum XTrimStrategy {
  MaxLen
  MinID
}

#
ZAddMember

source
pub(all) struct ZAddMember {
  score : String
  value : String
}

#
connect

source
async fn connect(host : String, port : Int) -> RedisClient

#
parse_redis_response

source
fn parse_redis_response(response : String) -> RedisValue

解析Redis协议响应

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io