🥮 mooncakes.io

    redis

    A modern, high performance Redis client for MoonBit.

    redis
    client
    valkey
    Download zip
    Author
    Version
    0.2.1
    License
    Apache-2.0
    Repository
    Last updated
    3 days ago
    Downloads
    57

    Dependencies

    #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", port=6379)
        defer client.close()
        let pong = client.ping()
        assert_true(pong is Ok("PONG"))
      })
    }

    #Authentication and Database Selection

    connect accepts optional password?, username? (Redis 6+ ACL) and db? arguments. AUTH and SELECT are sent automatically after the connection is established; failures raise ConnectError and close the connection.
    ///|
    async test "connect_with_auth" {
      @async.with_task_group(async fn(_root) {
        let client = @redis.connect(
          "localhost",
          port=6379,
          username="default",
          password="secret",
          db=1,
        )
        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]

    常用的具体返回类型

    ConnectError

    source
    pub(all) suberror ConnectError {
      AuthFailed(String)
      SelectFailed(String)
    }

    连接建立过程中的错误

    Bit

    source
    pub(all) enum Bit {
      Zero
      One
    }

    impl Show for Bit

    Bit::output

    source
    fn Bit::output(self : Bit, logger : &Logger) -> Unit

    Bit::to_string

    source
    fn Bit::to_string(self : Bit) -> String

    BitFieldEncoding

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

    BitFieldEncoding::output

    source
    fn BitFieldEncoding::output(self : BitFieldEncoding, logger : &Logger) -> Unit

    BitFieldEncoding::to_string

    source
    fn BitFieldEncoding::to_string(self : BitFieldEncoding) -> String

    BitFieldOperation

    source
    pub(all) enum BitFieldOperation {
      Get(encoding~ : BitFieldEncoding, offset~ : Int)
      Set(encoding~ : BitFieldEncoding, offset~ : Int, value~ : Bit)
      Incrby(encoding~ : BitFieldEncoding, offset~ : Int, value~ : Int)
      Overflow(behavior~ : 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

    GeoUnits::output

    source
    fn GeoUnits::output(self : GeoUnits, logger : &Logger) -> Unit

    GeoUnits::to_string

    source
    fn GeoUnits::to_string(self : GeoUnits) -> String

    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

    RedisStream::output

    source
    fn RedisStream::output(self : RedisStream, logger : &Logger) -> Unit

    RedisStream::to_repr

    source

    RedisStream::to_string

    source
    fn RedisStream::to_string(self : RedisStream) -> String

    RedisStreamMessage

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

    RedisStreamMessage::output

    source
    fn RedisStreamMessage::output(self : RedisStreamMessage, logger : &Logger) -> Unit

    RedisStreamMessage::to_repr

    source

    RedisStreamMessage::to_string

    source
    fn RedisStreamMessage::to_string(self : RedisStreamMessage) -> String

    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::equal

    source
    fn RedisValue::equal(RedisValue, RedisValue) -> Bool

    RedisValue::hash

    source
    fn RedisValue::hash(self : RedisValue) -> Int

    RedisValue::hash_combine

    source
    fn RedisValue::hash_combine(RedisValue, Hasher) -> Unit

    RedisValue::not_equal

    source
    fn RedisValue::not_equal(x : RedisValue, y : RedisValue) -> Bool

    RedisValue::output

    source
    fn RedisValue::output(self : RedisValue, logger : &Logger) -> Unit

    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_repr

    source

    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 : StringView, port? : Int, protocol? : 
    IpProtocolPreference    , username? : String, password? : String, db? : Int) -> RedisClient

    建立到 Redis 服务器的连接。

    连接建立后可选地自动完成认证和选库：
    • password?：提供时自动发送 AUTH； 同时提供 username? 时使用 Redis 6+ ACL 形式 AUTH <username> <password>。 单独提供 username? 而不提供 password? 时不发送 AUTH（Redis 没有仅用户名的认证）。
    • db?：提供时自动发送 SELECT <db> 切换到指定数据库。

    认证或选库失败时会关闭连接并抛出 ConnectError。

    parse_redis_response

    source
    fn parse_redis_response(response : String) -> RedisValue

    解析Redis协议响应

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io