Module type `Redis.S`Source

Sourcemodule Key : sig ... end

Sourcemodule Field : sig ... end

Sourcemodule Value : sig ... end

Sourcetype 'a t

val create' : 
  ?on_disconnect:(unit -> unit) ->
  ?auth:Auth.t ->
  where_to_connect:[< Async.Socket.Address.t ] Async.Tcp.Where_to_connect.t ->
  'a ->
  'a t Async.Deferred.Or_error.t

Source

val create : 
  ?on_disconnect:(unit -> unit) ->
  ?auth:Auth.t ->
  where_to_connect:[< Async.Socket.Address.t ] Async.Tcp.Where_to_connect.t ->
  unit ->
  [ `Primary ] t Async.Deferred.Or_error.t

Source

val create_using_sentinel : 
  ?on_disconnect:(unit -> unit) ->
  ?sentinel_auth:Auth.t ->
  ?auth:Auth.t ->
  leader_name:string ->
  where_to_connect:
    [< Async.Socket.Address.t ] Async.Tcp.Where_to_connect.t list ->
  unit ->
  [ `Primary ] t Async.Deferred.Or_error.t

Sourceval close : _ t -> unit Async.Deferred.t

Sourceval close_finished : _ t -> unit Async.Deferred.t

Sourceval has_close_started : _ t -> bool

Redis commands are documented at: https://redis.io/commands

Source

val select : 
  [< `Primary | `Replica ] t ->
  int ->
  unit Async.Deferred.Or_error.t

Sourceval flushall : [< `Primary ] t -> unit Async.Deferred.Or_error.t

Sourceval flushdb : [< `Primary ] t -> unit Async.Deferred.Or_error.t

Source

val shutdown : 
  [< `Primary | `Replica | `Sentinel ] t ->
  unit Async.Deferred.Or_error.t

Source

val echo : 
  [< `Primary | `Replica ] t ->
  Key.t ->
  Key.t Async.Deferred.Or_error.t

Source

val ping : 
  [< `Primary | `Replica | `Sentinel ] t ->
  string ->
  string Async.Deferred.Or_error.t

Sourceval incr : [< `Primary ] t -> Key.t -> int Async.Deferred.Or_error.t

Sourceval del : [< `Primary ] t -> Key.t list -> int Async.Deferred.Or_error.t

Sourceval unlink : [< `Primary ] t -> Key.t list -> int Async.Deferred.Or_error.t

Sourceval dbsize : [< `Primary | `Replica ] t -> int Async.Deferred.Or_error.t

Source

val exists : 
  [< `Primary | `Replica ] t ->
  Key.t list ->
  int Async.Deferred.Or_error.t

Source

val keys : 
  ?pattern:string ->
  [< `Primary | `Replica ] t ->
  Key.t list Async.Deferred.Or_error.t

Source

val rename : 
  [< `Primary ] t ->
  Key.t ->
  new_key:Key.t ->
  unit Async.Deferred.Or_error.t

Source

val scan : 
  [< `Primary | `Replica ] t ->
  cursor:Cursor.t ->
  ?count:int ->
  ?pattern:string ->
  unit ->
  (Cursor.t * Key.t list) Async.Deferred.Or_error.t

Source

val client_tracking : 
  [< `Primary | `Replica ] t ->
  ?bcast:bool ->
  unit ->
  [ `All | `Key of Key.t ] Async.Pipe.Reader.t Async.Deferred.Or_error.t

Turn on Redis client tracking and provide a pipe of invalidation messages received from the server. Closing the pipe turns tracking off.

The NOLOOP option is used, which means that subscribers will not see invalidation messages caused by themselves, unless it is from the flushdb / flushall command.

Read here for more on usage: https://redis.io/commands/client-tracking https://redis.io/topics/client-side-caching

parameter bcast
Whether to use BCAST. Off by default.

Source

val set : 
  [< `Primary ] t ->
  Key.t ->
  ?expire:Core.Time_ns.Span.t ->
  Value.t ->
  unit Async.Deferred.Or_error.t

Source

val setnx : 
  [< `Primary ] t ->
  Key.t ->
  Value.t ->
  bool Async.Deferred.Or_error.t

Source

val mset : 
  [< `Primary ] t ->
  (Key.t * Value.t) list ->
  unit Async.Deferred.Or_error.t

Source

val msetnx : 
  [< `Primary ] t ->
  (Key.t * Value.t) list ->
  bool Async.Deferred.Or_error.t

Source

val get : 
  [< `Primary | `Replica ] t ->
  Key.t ->
  Value.t option Async.Deferred.Or_error.t

Source

val mget : 
  [< `Primary ] t ->
  Key.t list ->
  Value.t option list Async.Deferred.Or_error.t

Source

val smembers : 
  [< `Primary | `Replica ] t ->
  Key.t ->
  Value.t list Async.Deferred.Or_error.t

Source

val sismember : 
  [< `Primary | `Replica ] t ->
  Key.t ->
  Value.t ->
  bool Async.Deferred.Or_error.t

Source

val smismember : 
  [< `Primary | `Replica ] t ->
  Key.t ->
  Value.t list ->
  bool list Async.Deferred.Or_error.t

Source

val sadd : 
  [< `Primary ] t ->
  Key.t ->
  Value.t list ->
  int Async.Deferred.Or_error.t

Source

val srem : 
  [< `Primary ] t ->
  Key.t ->
  Value.t list ->
  int Async.Deferred.Or_error.t

Source

val zadd : 
  [< `Primary ] t ->
  Key.t ->
  ([ `Score of float ] * Value.t) list ->
  int Async.Deferred.Or_error.t

Source

val zrem : 
  [< `Primary ] t ->
  Key.t ->
  Value.t list ->
  int Async.Deferred.Or_error.t

Source

val pttl : 
  [< `Primary | `Replica ] t ->
  Key.t ->
  [ `Timeout of Core.Time_ns.Span.t | `No_timeout | `No_key ]
    Async.Deferred.Or_error.t

Source

val pexpire : 
  [< `Primary ] t ->
  Key.t ->
  ?nx:bool ->
  Core.Time_ns.Span.t ->
  [ `Set | `Not_set ] Async.Deferred.Or_error.t

Source

val pexpireat : 
  [< `Primary ] t ->
  Key.t ->
  ?nx:bool ->
  Core.Time_ns.t ->
  [ `Set | `Not_set ] Async.Deferred.Or_error.t

Source

val zrange : 
  [< `Primary | `Replica ] t ->
  Key.t ->
  min_index:int ->
  max_index:int ->
  Value.t list Async.Deferred.Or_error.t

Source

val zscore : 
  [< `Primary | `Replica ] t ->
  Key.t ->
  Value.t ->
  [ `Score of float ] option Async.Deferred.Or_error.t

Source

val zrangebylex : 
  [< `Primary | `Replica ] t ->
  Key.t ->
  min:Value.t Core.Maybe_bound.t ->
  max:Value.t Core.Maybe_bound.t ->
  Value.t list Async.Deferred.Or_error.t

Source

val zrangebyscore : 
  [< `Primary | `Replica ] t ->
  Key.t ->
  min_score:float Core.Maybe_bound.t ->
  max_score:float Core.Maybe_bound.t ->
  Value.t list Async.Deferred.Or_error.t

Source

val zrangebyscore_withscores : 
  [< `Primary | `Replica ] t ->
  Key.t ->
  min_score:float Core.Maybe_bound.t ->
  max_score:float Core.Maybe_bound.t ->
  (Value.t * [ `Score of float ]) list Async.Deferred.Or_error.t

Source

val zremrangebyscore : 
  [< `Primary ] t ->
  Key.t ->
  min_score:float Core.Maybe_bound.t ->
  max_score:float Core.Maybe_bound.t ->
  int Async.Deferred.Or_error.t

Source

val hexists : 
  [< `Primary | `Replica ] t ->
  Key.t ->
  Field.t ->
  bool Async.Deferred.Or_error.t

Source

val hset : 
  [< `Primary ] t ->
  Key.t ->
  (Field.t * Value.t) list ->
  int Async.Deferred.Or_error.t

Source

val hget : 
  [< `Primary | `Replica ] t ->
  Key.t ->
  Field.t ->
  Value.t option Async.Deferred.Or_error.t

Source

val hmget : 
  [< `Primary | `Replica ] t ->
  Key.t ->
  Field.t list ->
  Value.t option list Async.Deferred.Or_error.t

Source

val hgetall : 
  [< `Primary | `Replica ] t ->
  Key.t ->
  (Field.t * Value.t) list Async.Deferred.Or_error.t

Source

val hvals : 
  [< `Primary | `Replica ] t ->
  Key.t ->
  Value.t list Async.Deferred.Or_error.t

Source

val hkeys : 
  [< `Primary | `Replica ] t ->
  Key.t ->
  Field.t list Async.Deferred.Or_error.t

Sourceval hlen : [< `Primary | `Replica ] t -> Key.t -> int Async.Deferred.Or_error.t

Source

val hdel : 
  [< `Primary ] t ->
  Key.t ->
  Field.t list ->
  int Async.Deferred.Or_error.t

Source

val hscan : 
  [< `Primary | `Replica ] t ->
  cursor:Cursor.t ->
  ?count:int ->
  Key.t ->
  (Cursor.t * (Field.t * Value.t) list) Async.Deferred.Or_error.t

Source

val keyevent_notifications : 
  [< `Primary | `Replica ] t ->
  ([< Key_event.t ] as 'a) list ->
  ('a * Key.t) Async.Pipe.Reader.t Async.Deferred.Or_error.t

Source

val keyspace_notifications : 
  [< `Primary | `Replica ] t ->
  ([< Key_event.t ] as 'a) list ->
  [ `Patterns of string list | `Keys of Key.t list ] ->
  ('a * Key.t) Async.Pipe.Reader.t Async.Deferred.Or_error.t

Source

val publish : 
  [< `Primary | `Replica ] t ->
  string ->
  Key.t ->
  int Async.Deferred.Or_error.t

Source

val subscribe : 
  [< `Primary | `Replica ] t ->
  string list ->
  (string * Key.t) Async.Pipe.Reader.t Async.Deferred.Or_error.t

Source

val subscribe_raw : 
  [< `Primary | `Replica ] t ->
  [ `Literal of string list | `Pattern of string list ] ->
  consume:((Core.read, Iobuf.seek) Iobuf.t -> subscription:string -> 'a) ->
  'a Async.Pipe.Reader.t Async.Deferred.Or_error.t

Source

val psubscribe : 
  [< `Primary | `Replica ] t ->
  string list ->
  (string * Key.t) Async.Pipe.Reader.t Async.Deferred.Or_error.t

Source

val script_load : 
  [< `Primary | `Replica ] t ->
  string ->
  Sha1.t Async.Deferred.Or_error.t

Source

val evalsha : 
  [< `Primary | `Replica ] t ->
  Sha1.t ->
  Key.t list ->
  Value.t list ->
  Resp3.t Async.Deferred.Or_error.t

Source

val raw_command : 
  [< `Primary | `Replica | `Sentinel ] t ->
  string list ->
  Resp3.t Async.Deferred.Or_error.t

Source

val version : 
  [< `Primary | `Replica | `Sentinel ] t ->
  string Async.Deferred.Or_error.t

Source

val role : 
  [< `Primary | `Replica | `Sentinel ] t ->
  Role.t Async.Deferred.Or_error.t

Source

val acl_setuser : 
  [< `Primary | `Replica | `Sentinel ] t ->
  username:string ->
  rules:string list ->
  unit Async.Deferred.Or_error.t

ACL and authentication commands.

Read here for more:

https://redis.io/docs/manual/security/acl/#command-categories https://redis.io/docs/manual/security/acl/#selectors

Source

val acl_deluser : 
  [< `Primary | `Replica | `Sentinel ] t ->
  string list ->
  int Async.Deferred.Or_error.t

Source

val acl_users : 
  [< `Primary | `Replica | `Sentinel ] t ->
  string list Async.Deferred.Or_error.t

Source

val acl_list : 
  [< `Primary | `Replica | `Sentinel ] t ->
  string list Async.Deferred.Or_error.t

Source

val acl_getuser : 
  [< `Primary | `Replica | `Sentinel ] t ->
  username:string ->
  Resp3.t Async.Deferred.Or_error.t

Source

val auth : 
  [< `Primary | `Replica | `Sentinel ] t ->
  auth:Auth.t ->
  unit ->
  unit Async.Deferred.Or_error.t

Source

val sentinel_leader : 
  [< `Sentinel ] t ->
  string ->
  Core.Host_and_port.t Async.Deferred.Or_error.t

Sentinel specific commands.

Read here for more: https://redis.io/docs/manual/sentinel/#sentinel-api

Streams

Source

val xadd : 
  [< `Primary ] t ->
  Key.t ->
  ?stream_id:Stream_id.t ->
  (Field.t * Value.t) list ->
  Stream_id.t Async.Deferred.Or_error.t

Source

val xgroup_create : 
  [< `Primary ] t ->
  Key.t ->
  Group.t ->
  ?stream_id:Stream_id.t ->
  ?mkstream:unit ->
  unit ->
  [ `Ok | `Already_exists ] Async.Deferred.Or_error.t

Source

val xrange : 
  [< `Primary | `Replica ] t ->
  Key.t ->
  ?start:Stream_id.t ->
  ?end_:Stream_id.t ->
  ?count:int ->
  unit ->
  (Stream_id.t * (Field.t * Value.t) list) list Async.Deferred.Or_error.t

Source

val xreadgroup : 
  [< `Primary | `Replica ] t ->
  Group.t ->
  Consumer.t ->
  ?count:int ->
  ?block:[ `Don't_block | `Forever | `For_up_to of Core.Time_ns.Span.t ] ->
  (Key.t * Stream_id.t option) list ->
  (Key.t * (Stream_id.t * (Field.t * Value.t) list) list) list
    Async.Deferred.Or_error.t

Source

val xclaim : 
  [< `Primary ] t ->
  ?idle:Core.Time_ns.Span.t ->
  Key.t ->
  Group.t ->
  Consumer.t ->
  min_idle_time:Core.Time_ns.Span.t ->
  Stream_id.t list ->
  (Stream_id.t * (Field.t * Value.t) list) list Async.Deferred.Or_error.t

Source

val xclaim_justid : 
  [< `Primary ] t ->
  ?idle:Core.Time_ns.Span.t ->
  Key.t ->
  Group.t ->
  Consumer.t ->
  min_idle_time:Core.Time_ns.Span.t ->
  Stream_id.t list ->
  Stream_id.t list Async.Deferred.Or_error.t

Source

val xautoclaim : 
  [< `Primary ] t ->
  Key.t ->
  Group.t ->
  Consumer.t ->
  min_idle_time:Core.Time_ns.Span.t ->
  start:Stream_id.t ->
  ?count:int ->
  unit ->
  ([ `Next_stream_id of Stream_id.t ]
   * (Stream_id.t * (Field.t * Value.t) list) list
   * [ `No_longer_exist of Stream_id.t list ])
    Async.Deferred.Or_error.t

Source

val xack : 
  [< `Primary ] t ->
  Key.t ->
  Group.t ->
  Stream_id.t list ->
  int Async.Deferred.Or_error.t

package redis-async

Module type Redis.SSource

Module type `Redis.S`Source