userver: storages::redis Namespace Reference
Loading...
Searching...
No Matches
storages::redis Namespace Reference

Detailed Description

Redis client and helpers.

Classes

class  Client
 Redis client. More...
 
class  ClientNotConnectedException
 Cannot connect to some redis server shard. More...
 
struct  CommandControl
 Redis command execution options. More...
 
struct  CommandsBufferingSettings
 
struct  Config
 
struct  ConnectionInfo
 
class  EmptyTransactionException
 
class  Exception
 Generic redis-related exception. More...
 
class  ExpireReply
 
struct  GeoaddArg
 
struct  GeoPoint
 
struct  GeoradiusOptions
 
struct  GeosearchOptions
 
class  InvalidArgumentException
 Invalid redis command argument. More...
 
class  KeyHasNoExpirationException
 Trying to get expiration from a nonexistent or a persistent key. More...
 
struct  MemberScore
 
struct  MetricsSettings
 
class  NotStartedTransactionException
 
class  ParseConfigException
 Invalid config format. More...
 
class  ParseReplyException
 Invalid reply data format. More...
 
struct  Point
 
struct  PublishSettings
 
struct  PubsubMetricsSettings
 
struct  RangeOptions
 
struct  RangeScoreOptions
 
struct  RedisWaitConnected
 Connection wait options for the Redis; mostly used by storages::redis::Client::WaitConnectedOnce. More...
 
struct  ReplicationMonitoringSettings
 
class  Reply
 
class  ReplyData
 
class  Request
 Redis future for a non-scan and non-eval responses. More...
 
class  RequestCancelledException
 Request was cancelled. More...
 
class  RequestDataBase
 
class  RequestEval
 Redis future for a non-scan and non-eval responses. More...
 
class  RequestEvalSha
 
class  RequestFailedException
 Request execution failed. More...
 
class  RequestScanData
 
class  RequestScanDataBase
 
struct  RetryNilFromMaster
 
class  ScanOptionsBase
 
class  ScanOptionsTmpl
 
struct  ScanReplyElem
 
struct  ScanReplyElem< ScanTag::kHscan >
 
struct  ScanReplyElem< ScanTag::kScan >
 
struct  ScanReplyElem< ScanTag::kSscan >
 
struct  ScanReplyElem< ScanTag::kZscan >
 
class  ScanRequest
 Redis future for a SCAN-like responses. More...
 
struct  ScoreOptions
 
class  ServerId
 Opaque Id of Redis server instance / any server instance. More...
 
struct  ServerIdHasher
 
struct  SetOptions
 
struct  Stat
 
class  SubscribeClient
 Client that allows subscribing to Redis channel messages. More...
 
class  SubscriptionToken
 RAII subscription guard, that is usually retrieved from storages::redis::SubscribeClient. More...
 
struct  To
 
class  Transaction
 Atomic sequence of Redis commands (https://redis.io/topics/transactions), that is usually retrieved from storages::redis::Client::Multi(). More...
 
class  TtlReply
 
struct  ZaddOptions
 

Typedefs

using Password = utils::NonLoggable<class PasswordTag, std::string>
 
using ScanCursor = int64_t
 
using ClientPtr = std::shared_ptr<Client>
 
using SubscribeClientPtr = std::shared_ptr<SubscribeClient>
 
using Longitude = utils::StrongTypedef<struct LongitudeTag, double>
 
using Latitude = utils::StrongTypedef<struct LatitudeTag, double>
 
using BoxWidth = utils::StrongTypedef<struct BoxWidthTag, double>
 
using BoxHeight = utils::StrongTypedef<struct BoxHeightTag, double>
 
using ScanOptions = ScanOptionsTmpl<ScanTag::kScan>
 
using SscanOptions = ScanOptionsTmpl<ScanTag::kSscan>
 
using HscanOptions = ScanOptionsTmpl<ScanTag::kHscan>
 
using ZscanOptions = ScanOptionsTmpl<ScanTag::kZscan>
 
using ReplyPtr = std::shared_ptr<Reply>
 
template<typename RedisRequestType >
using HedgedRedisRequest = utils::hedging::HedgedRequestFuture<impl::RedisRequestStrategy<RedisRequestType>>
 
using TransactionPtr = std::unique_ptr<Transaction>
 
Redis futures aliases
using RequestAppend = Request<size_t>
 
using RequestBitop = Request<size_t>
 
using RequestDbsize = Request<size_t>
 
using RequestDecr = Request<int64_t>
 
using RequestDel = Request<size_t>
 
using RequestUnlink = Request<size_t>
 
using RequestEvalCommon = Request<ReplyData>
 
using RequestEvalShaCommon = Request<ReplyData>
 
using RequestScriptLoad = Request<std::string>
 
using RequestExec = Request<ReplyData, void>
 
using RequestExists = Request<size_t>
 
using RequestExpire = Request<ExpireReply>
 
using RequestGeoadd = Request<size_t>
 
using RequestGeoradius = Request<std::vector<GeoPoint>>
 
using RequestGeosearch = Request<std::vector<GeoPoint>>
 
using RequestGet = Request<std::optional<std::string>>
 
using RequestGetset = Request<std::optional<std::string>>
 
using RequestHdel = Request<size_t>
 
using RequestHexists = Request<size_t>
 
using RequestHget = Request<std::optional<std::string>>
 
using RequestHgetall = Request<std::unordered_map<std::string, std::string>>
 
using RequestHincrby = Request<int64_t>
 
using RequestHincrbyfloat = Request<double>
 
using RequestHkeys = Request<std::vector<std::string>>
 
using RequestHlen = Request<size_t>
 
using RequestHmget = Request<std::vector<std::optional<std::string>>>
 
using RequestHmset = Request<StatusOk, void>
 
using RequestHscan = ScanRequest<ScanTag::kHscan>
 
using RequestHset = Request<HsetReply>
 
using RequestHsetnx = Request<size_t, bool>
 
using RequestHvals = Request<std::vector<std::string>>
 
using RequestIncr = Request<int64_t>
 
using RequestKeys = Request<std::vector<std::string>>
 
using RequestLindex = Request<std::optional<std::string>>
 
using RequestLlen = Request<size_t>
 
using RequestLpop = Request<std::optional<std::string>>
 
using RequestLpush = Request<size_t>
 
using RequestLpushx = Request<size_t>
 
using RequestLrange = Request<std::vector<std::string>>
 
using RequestLrem = Request<size_t>
 
using RequestLtrim = Request<StatusOk, void>
 
using RequestMget = Request<std::vector<std::optional<std::string>>>
 
using RequestMset = Request<StatusOk, void>
 
using RequestPersist = Request<PersistReply>
 
using RequestPexpire = Request<ExpireReply>
 
using RequestPing = Request<StatusPong, void>
 
using RequestPingMessage = Request<std::string>
 
using RequestPublish = Request<size_t>
 
using RequestRename = Request<StatusOk, void>
 
using RequestRpop = Request<std::optional<std::string>>
 
using RequestRpush = Request<size_t>
 
using RequestRpushx = Request<size_t>
 
using RequestSadd = Request<size_t>
 
using RequestScan = ScanRequest<ScanTag::kScan>
 
using RequestScard = Request<size_t>
 
using RequestSet = Request<StatusOk, void>
 
using RequestSetIfExist = Request<std::optional<StatusOk>, bool>
 
using RequestSetIfNotExist = Request<std::optional<StatusOk>, bool>
 
using RequestSetOptions = Request<SetReply>
 
using RequestSetex = Request<StatusOk, void>
 
using RequestSismember = Request<size_t>
 
using RequestSmembers = Request<std::unordered_set<std::string>>
 
using RequestSrandmember = Request<std::optional<std::string>>
 
using RequestSrandmembers = Request<std::vector<std::string>>
 
using RequestSrem = Request<size_t>
 
using RequestSscan = ScanRequest<ScanTag::kSscan>
 
using RequestStrlen = Request<size_t>
 
using RequestTime = Request<std::chrono::system_clock::time_point>
 
using RequestTtl = Request<TtlReply>
 
using RequestType = Request<KeyType>
 
using RequestZadd = Request<size_t>
 
using RequestZaddIncr = Request<double>
 
using RequestZaddIncrExisting = Request<std::optional<double>>
 
using RequestZcard = Request<size_t>
 
using RequestZcount = Request<size_t>
 
using RequestZrange = Request<std::vector<std::string>>
 
using RequestZrangeWithScores = Request<std::vector<MemberScore>>
 
using RequestZrangebyscore = Request<std::vector<std::string>>
 
using RequestZrangebyscoreWithScores = Request<std::vector<MemberScore>>
 
using RequestZrem = Request<size_t>
 
using RequestZremrangebyrank = Request<size_t>
 
using RequestZremrangebyscore = Request<size_t>
 
using RequestZscan = ScanRequest<ScanTag::kZscan>
 
using RequestZscore = Request<std::optional<double>>
 

Enumerations

enum class  ConnectionSecurity {
  kNone ,
  kTLS
}
 
enum class  ConnectionMode {
  kCommands ,
  kSubscriber
}
 
enum class  BitOperation {
  kAnd ,
  kOr ,
  kXor ,
  kNot
}
 
enum class  PubShard {
  kZeroShard ,
  kRoundRobin
}
 
enum class  KeyType {
  kNone ,
  kString ,
  kList ,
  kSet ,
  kZset ,
  kHash ,
  kStream
}
 Type of the Redis value stored by a key. More...
 
enum class  RedisState {
  kInit = 0 ,
  kInitError ,
  kConnected ,
  kDisconnecting ,
  kDisconnected ,
  kDisconnectError
}
 Represents the state of redis instance connection. More...
 
enum class  ReplyStatus {
  kOk = 0 ,
  kInputOutputError ,
  kOtherError ,
  kEndOfFileError ,
  kProtocolError ,
  kOutOfMemoryError ,
  kTimeoutError
}
 Redis reply status. More...
 
enum class  HsetReply {
  kCreated ,
  kUpdated
}
 
enum class  PersistReply {
  kKeyOrTimeoutNotFound ,
  kTimeoutRemoved
}
 
enum class  SetReply {
  kSet ,
  kNotSet
}
 
enum class  StatusOk { kOk }
 
enum class  StatusPong { kPong }
 
enum class  ScanTag {
  kScan ,
  kSscan ,
  kHscan ,
  kZscan
}
 Enum that distinguished different SCAN requests for the storages::redis::ScanRequest. More...
 
enum class  WaitConnectedMode {
  kNoWait ,
  kMaster ,
  kMasterOrSlave ,
  kSlave ,
  kMasterAndSlave
}
 Connection wait mode for the Redis. More...
 

Functions

std::string ToString (BitOperation bitop)
 
std::string CreateTmpKey (const std::string &key, std::string prefix)
 
CommandControl::Strategy StrategyFromString (std::string_view s)
 Returns CommandControl::Strategy from string.
 
std::string_view StrategyToString (CommandControl::Strategy s)
 Returns string representation of CommandControl::Strategy.
 
constexpr ZaddOptions operator| (ZaddOptions::Exist exist, ZaddOptions::ReturnValue return_value)
 
constexpr ZaddOptions operator| (ZaddOptions::Exist exist, ZaddOptions::Compare compare)
 
constexpr ZaddOptions operator| (ZaddOptions::Compare compare, ZaddOptions::Exist exist)
 
constexpr ZaddOptions operator| (ZaddOptions::Compare compare, ZaddOptions::ReturnValue return_value)
 
constexpr ZaddOptions operator| (ZaddOptions::ReturnValue return_value, ZaddOptions::Exist exist)
 
constexpr ZaddOptions operator| (ZaddOptions::ReturnValue return_value, ZaddOptions::Compare compare)
 
template<typename RedisRequestType , typename... Args, typename M = RedisRequestType (storages::redis::Client::*)(Args..., const redis::CommandControl&)>
HedgedRedisRequest< RedisRequestType > MakeHedgedRedisRequestAsync (std::shared_ptr< storages::redis::Client > redis, M method, const redis::CommandControl &cc, utils::hedging::HedgingSettings hedging_settings, Args... args)
 
template<typename RedisRequestType , typename... Args, typename M = RedisRequestType (storages::redis::Client::*)(Args..., const redis::CommandControl&)>
std::optional< typename RedisRequestType::Reply > MakeHedgedRedisRequest (std::shared_ptr< storages::redis::Client > redis, M method, const redis::CommandControl &cc, utils::hedging::HedgingSettings hedging_settings, Args... args)
 
template<typename RedisRequestType , typename... Args, typename M = RedisRequestType (storages::redis::Client::*)(Args..., const redis::CommandControl&)>
std::vector< std::optional< typename RedisRequestType::Reply > > MakeBulkHedgedRedisRequest (std::shared_ptr< storages::redis::Client > redis, M method, const redis::CommandControl &cc, utils::hedging::HedgingSettings hedging_settings, std::vector< std::tuple< Args... > > args)
 
template<typename RedisRequestType , typename... Args, typename M = RedisRequestType (storages::redis::Client::*)(Args..., const redis::CommandControl&)>
utils::hedging::HedgedRequestBulkFuture< redis::impl::RedisRequestStrategy< RedisRequestType > > MakeBulkHedgedRedisRequestAsync (std::shared_ptr< storages::redis::Client > redis, M method, const redis::CommandControl &cc, utils::hedging::HedgingSettings hedging_settings, std::vector< std::tuple< Args... > > args)
 
KeyType ParseKeyType (std::string_view str)
 
std::string ToString (KeyType key_type)
 
std::vector< std::string > ParseReplyDataArray (ReplyData &&array_data, const std::string &request_description, To< std::vector< std::string > >)
 
std::vector< std::optional< std::string > > ParseReplyDataArray (ReplyData &&array_data, const std::string &request_description, To< std::vector< std::optional< std::string > > >)
 
std::vector< std::pair< std::string, std::string > > ParseReplyDataArray (ReplyData &&array_data, const std::string &request_description, To< std::vector< std::pair< std::string, std::string > > >)
 
std::vector< MemberScoreParseReplyDataArray (ReplyData &&array_data, const std::string &request_description, To< std::vector< MemberScore > >)
 
std::vector< GeoPointParseReplyDataArray (ReplyData &&array_data, const std::string &request_description, To< std::vector< GeoPoint > >)
 
std::string Parse (ReplyData &&reply_data, const std::string &request_description, To< std::string >)
 
double Parse (ReplyData &&reply_data, const std::string &request_description, To< double >)
 
size_t Parse (ReplyData &&reply_data, const std::string &request_description, To< size_t >)
 
bool Parse (ReplyData &&reply_data, const std::string &request_description, To< size_t, bool >)
 
int64_t Parse (ReplyData &&reply_data, const std::string &request_description, To< int64_t >)
 
std::chrono::system_clock::time_point Parse (ReplyData &&reply_data, const std::string &request_description, To< std::chrono::system_clock::time_point >)
 
HsetReply Parse (ReplyData &&reply_data, const std::string &request_description, To< HsetReply >)
 
PersistReply Parse (ReplyData &&reply_data, const std::string &request_description, To< PersistReply >)
 
KeyType Parse (ReplyData &&reply_data, const std::string &request_description, To< KeyType >)
 
void Parse (ReplyData &&reply_data, const std::string &request_description, To< StatusOk, void >)
 
bool Parse (ReplyData &&reply_data, const std::string &request_description, To< std::optional< StatusOk >, bool >)
 
void Parse (ReplyData &&reply_data, const std::string &request_description, To< StatusPong, void >)
 
SetReply Parse (ReplyData &&reply_data, const std::string &request_description, To< SetReply >)
 
std::unordered_set< std::string > Parse (ReplyData &&reply_data, const std::string &request_description, To< std::unordered_set< std::string > >)
 
std::unordered_map< std::string, std::string > Parse (ReplyData &&reply_data, const std::string &request_description, To< std::unordered_map< std::string, std::string > >)
 
ReplyData Parse (ReplyData &&reply_data, const std::string &request_description, To< ReplyData >)
 
template<typename Result , typename ReplyType = Result>
std::enable_if_t< impl::HasParseFunctionFromRedisReply< Result, ReplyType >::value, ReplyType > Parse (ReplyData &&reply_data, const std::string &request_description, To< Result, ReplyType >)
 
template<typename T >
std::vector< T > Parse (ReplyData &&reply_data, const std::string &request_description, To< std::vector< T > >)
 
template<typename T >
std::optional< T > Parse (ReplyData &&reply_data, const std::string &request_description, To< std::optional< T > >)
 
template<typename Result , typename ReplyType = Result>
ReplyType ParseReply (ReplyPtr reply, const std::string &request_description={})
 
CommandControl Parse (const formats::json::Value &elem, formats::parse::To< CommandControl >)
 
CommandControl::Strategy Parse (const formats::json::Value &elem, formats::parse::To< CommandControl::Strategy >)
 
WaitConnectedMode Parse (const formats::json::Value &elem, formats::parse::To< WaitConnectedMode >)
 
RedisWaitConnected Parse (const formats::json::Value &elem, formats::parse::To< RedisWaitConnected >)
 
CommandsBufferingSettings Parse (const formats::json::Value &elem, formats::parse::To< CommandsBufferingSettings >)
 
MetricsSettings::DynamicSettings Parse (const formats::json::Value &elem, formats::parse::To< MetricsSettings::DynamicSettings >)
 
ReplicationMonitoringSettings Parse (const formats::json::Value &elem, formats::parse::To< ReplicationMonitoringSettings >)
 
PubsubMetricsSettings Parse (const formats::json::Value &elem, formats::parse::To< PubsubMetricsSettings >)
 
std::string ToString (WaitConnectedMode mode)
 
WaitConnectedMode Parse (const std::string &str, formats::parse::To< WaitConnectedMode >)
 

Variables

constexpr std::chrono::milliseconds kDefaultTimeoutSingle {500}
 
constexpr std::chrono::milliseconds kDefaultTimeoutAll {2000}
 
constexpr std::size_t kDefaultMaxRetries {4}
 
constexpr RetryNilFromMaster kRetryNilFromMaster {}
 
const dynamic_config::Key< ConfigkConfig
 
constexpr auto kRedisWaitConnectedDefaultTimeout = std::chrono::seconds(11)
 Default timeout for Redis connection wait.
 

Typedef Documentation

◆ BoxHeight

using storages::redis::BoxHeight = utils::StrongTypedef<struct BoxHeightTag, double>

Definition at line 19 of file command_options.hpp.

◆ BoxWidth

using storages::redis::BoxWidth = utils::StrongTypedef<struct BoxWidthTag, double>

Definition at line 18 of file command_options.hpp.

◆ ClientPtr

using storages::redis::ClientPtr = std::shared_ptr<Client>

Definition at line 10 of file client_fwd.hpp.

◆ HedgedRedisRequest

template<typename RedisRequestType >
using storages::redis::HedgedRedisRequest = utils::hedging::HedgedRequestFuture<impl::RedisRequestStrategy<RedisRequestType>>

Definition at line 67 of file hedged_request.hpp.

◆ HscanOptions

◆ Latitude

using storages::redis::Latitude = utils::StrongTypedef<struct LatitudeTag, double>

Definition at line 17 of file command_options.hpp.

◆ Longitude

using storages::redis::Longitude = utils::StrongTypedef<struct LongitudeTag, double>

Definition at line 16 of file command_options.hpp.

◆ Password

using storages::redis::Password = utils::NonLoggable<class PasswordTag, std::string>

Definition at line 19 of file base.hpp.

◆ ReplyPtr

typedef std::shared_ptr< Reply > storages::redis::ReplyPtr = std::shared_ptr<Reply>

Definition at line 19 of file fwd.hpp.

◆ RequestAppend

Definition at line 159 of file request.hpp.

◆ RequestBitop

Definition at line 160 of file request.hpp.

◆ RequestDbsize

Definition at line 161 of file request.hpp.

◆ RequestDecr

Definition at line 162 of file request.hpp.

◆ RequestDel

Definition at line 163 of file request.hpp.

◆ RequestEvalCommon

Definition at line 165 of file request.hpp.

◆ RequestEvalShaCommon

◆ RequestExec

Definition at line 168 of file request.hpp.

◆ RequestExists

Definition at line 169 of file request.hpp.

◆ RequestExpire

Definition at line 170 of file request.hpp.

◆ RequestGeoadd

Definition at line 171 of file request.hpp.

◆ RequestGeoradius

Definition at line 172 of file request.hpp.

◆ RequestGeosearch

Definition at line 173 of file request.hpp.

◆ RequestGet

using storages::redis::RequestGet = Request<std::optional<std::string>>

Definition at line 174 of file request.hpp.

◆ RequestGetset

using storages::redis::RequestGetset = Request<std::optional<std::string>>

Definition at line 175 of file request.hpp.

◆ RequestHdel

Definition at line 176 of file request.hpp.

◆ RequestHexists

Definition at line 177 of file request.hpp.

◆ RequestHget

using storages::redis::RequestHget = Request<std::optional<std::string>>

Definition at line 178 of file request.hpp.

◆ RequestHgetall

using storages::redis::RequestHgetall = Request<std::unordered_map<std::string, std::string>>

Definition at line 179 of file request.hpp.

◆ RequestHincrby

Definition at line 180 of file request.hpp.

◆ RequestHincrbyfloat

Definition at line 181 of file request.hpp.

◆ RequestHkeys

using storages::redis::RequestHkeys = Request<std::vector<std::string>>

Definition at line 182 of file request.hpp.

◆ RequestHlen

Definition at line 183 of file request.hpp.

◆ RequestHmget

using storages::redis::RequestHmget = Request<std::vector<std::optional<std::string>>>

Definition at line 184 of file request.hpp.

◆ RequestHmset

using storages::redis::RequestHmset = Request<StatusOk, void>

Definition at line 185 of file request.hpp.

◆ RequestHscan

◆ RequestHset

Definition at line 187 of file request.hpp.

◆ RequestHsetnx

using storages::redis::RequestHsetnx = Request<size_t, bool>

Definition at line 188 of file request.hpp.

◆ RequestHvals

using storages::redis::RequestHvals = Request<std::vector<std::string>>

Definition at line 189 of file request.hpp.

◆ RequestIncr

Definition at line 190 of file request.hpp.

◆ RequestKeys

using storages::redis::RequestKeys = Request<std::vector<std::string>>

Definition at line 191 of file request.hpp.

◆ RequestLindex

using storages::redis::RequestLindex = Request<std::optional<std::string>>

Definition at line 192 of file request.hpp.

◆ RequestLlen

Definition at line 193 of file request.hpp.

◆ RequestLpop

using storages::redis::RequestLpop = Request<std::optional<std::string>>

Definition at line 194 of file request.hpp.

◆ RequestLpush

Definition at line 195 of file request.hpp.

◆ RequestLpushx

Definition at line 196 of file request.hpp.

◆ RequestLrange

using storages::redis::RequestLrange = Request<std::vector<std::string>>

Definition at line 197 of file request.hpp.

◆ RequestLrem

Definition at line 198 of file request.hpp.

◆ RequestLtrim

using storages::redis::RequestLtrim = Request<StatusOk, void>

Definition at line 199 of file request.hpp.

◆ RequestMget

using storages::redis::RequestMget = Request<std::vector<std::optional<std::string>>>

Definition at line 200 of file request.hpp.

◆ RequestMset

using storages::redis::RequestMset = Request<StatusOk, void>

Definition at line 201 of file request.hpp.

◆ RequestPersist

Definition at line 202 of file request.hpp.

◆ RequestPexpire

Definition at line 203 of file request.hpp.

◆ RequestPing

using storages::redis::RequestPing = Request<StatusPong, void>

Definition at line 204 of file request.hpp.

◆ RequestPingMessage

Definition at line 205 of file request.hpp.

◆ RequestPublish

Definition at line 206 of file request.hpp.

◆ RequestRename

using storages::redis::RequestRename = Request<StatusOk, void>

Definition at line 207 of file request.hpp.

◆ RequestRpop

using storages::redis::RequestRpop = Request<std::optional<std::string>>

Definition at line 208 of file request.hpp.

◆ RequestRpush

Definition at line 209 of file request.hpp.

◆ RequestRpushx

Definition at line 210 of file request.hpp.

◆ RequestSadd

Definition at line 211 of file request.hpp.

◆ RequestScan

◆ RequestScard

Definition at line 213 of file request.hpp.

◆ RequestScriptLoad

Definition at line 167 of file request.hpp.

◆ RequestSet

using storages::redis::RequestSet = Request<StatusOk, void>

Definition at line 214 of file request.hpp.

◆ RequestSetex

using storages::redis::RequestSetex = Request<StatusOk, void>

Definition at line 218 of file request.hpp.

◆ RequestSetIfExist

using storages::redis::RequestSetIfExist = Request<std::optional<StatusOk>, bool>

Definition at line 215 of file request.hpp.

◆ RequestSetIfNotExist

using storages::redis::RequestSetIfNotExist = Request<std::optional<StatusOk>, bool>

Definition at line 216 of file request.hpp.

◆ RequestSetOptions

Definition at line 217 of file request.hpp.

◆ RequestSismember

Definition at line 219 of file request.hpp.

◆ RequestSmembers

using storages::redis::RequestSmembers = Request<std::unordered_set<std::string>>

Definition at line 220 of file request.hpp.

◆ RequestSrandmember

using storages::redis::RequestSrandmember = Request<std::optional<std::string>>

Definition at line 221 of file request.hpp.

◆ RequestSrandmembers

using storages::redis::RequestSrandmembers = Request<std::vector<std::string>>

Definition at line 222 of file request.hpp.

◆ RequestSrem

Definition at line 223 of file request.hpp.

◆ RequestSscan

◆ RequestStrlen

Definition at line 225 of file request.hpp.

◆ RequestTime

using storages::redis::RequestTime = Request<std::chrono::system_clock::time_point>

Definition at line 226 of file request.hpp.

◆ RequestTtl

Definition at line 227 of file request.hpp.

◆ RequestType

Definition at line 228 of file request.hpp.

◆ RequestUnlink

Definition at line 164 of file request.hpp.

◆ RequestZadd

Definition at line 229 of file request.hpp.

◆ RequestZaddIncr

Definition at line 230 of file request.hpp.

◆ RequestZaddIncrExisting

using storages::redis::RequestZaddIncrExisting = Request<std::optional<double>>

Definition at line 231 of file request.hpp.

◆ RequestZcard

Definition at line 232 of file request.hpp.

◆ RequestZcount

Definition at line 233 of file request.hpp.

◆ RequestZrange

using storages::redis::RequestZrange = Request<std::vector<std::string>>

Definition at line 234 of file request.hpp.

◆ RequestZrangebyscore

using storages::redis::RequestZrangebyscore = Request<std::vector<std::string>>

Definition at line 236 of file request.hpp.

◆ RequestZrangebyscoreWithScores

Definition at line 237 of file request.hpp.

◆ RequestZrangeWithScores

Definition at line 235 of file request.hpp.

◆ RequestZrem

Definition at line 238 of file request.hpp.

◆ RequestZremrangebyrank

Definition at line 239 of file request.hpp.

◆ RequestZremrangebyscore

Definition at line 240 of file request.hpp.

◆ RequestZscan

◆ RequestZscore

using storages::redis::RequestZscore = Request<std::optional<double>>

Definition at line 242 of file request.hpp.

◆ ScanCursor

using storages::redis::ScanCursor = int64_t

Definition at line 53 of file base.hpp.

◆ ScanOptions

◆ SscanOptions

◆ SubscribeClientPtr

using storages::redis::SubscribeClientPtr = std::shared_ptr<SubscribeClient>

Definition at line 13 of file client_fwd.hpp.

◆ TransactionPtr

using storages::redis::TransactionPtr = std::unique_ptr<Transaction>

Definition at line 281 of file transaction.hpp.

◆ ZscanOptions

Enumeration Type Documentation

◆ BitOperation

enum class storages::redis::BitOperation
strong

Definition at line 9 of file bit_operation.hpp.

◆ ConnectionMode

enum class storages::redis::ConnectionMode
strong

Definition at line 67 of file base.hpp.

◆ ConnectionSecurity

enum class storages::redis::ConnectionSecurity
strong

Definition at line 21 of file base.hpp.

◆ HsetReply

enum class storages::redis::HsetReply
strong

Definition at line 19 of file reply_types.hpp.

◆ KeyType

enum class storages::redis::KeyType
strong

Type of the Redis value stored by a key.

Returned by storages::redis::Client and storages::redis::Transaction from membed function Type()

Definition at line 16 of file key_type.hpp.

◆ PersistReply

enum class storages::redis::PersistReply
strong

Definition at line 66 of file reply_types.hpp.

◆ PubShard

enum class storages::redis::PubShard
strong

Definition at line 25 of file client.hpp.

◆ RedisState

enum class storages::redis::RedisState
strong

Represents the state of redis instance connection.

Enumerator
kInit 

Initializing context and establishing connection.

kInitError 

Connection initialization failed.

kConnected 

Connection established and ready to send commands.

kDisconnecting 

Closing connection, all remaining commands are dropped.

kDisconnected 

Connection successfully closed.

kDisconnectError 

An error occurred while closing connection.

Definition at line 8 of file redis_state.hpp.

◆ ReplyStatus

enum class storages::redis::ReplyStatus
strong

Redis reply status.

Definition at line 8 of file reply_status.hpp.

◆ ScanTag

enum class storages::redis::ScanTag
strong

Enum that distinguished different SCAN requests for the storages::redis::ScanRequest.

Enumerator
kScan 

SCAN Redis command: iterates the set of keys in the currently selected Redis database.

kSscan 

SSCAN Redis command: iterates elements of Sets types.

kHscan 

HSCAN Redis command: iterates fields of Hash types and their associated values.

kZscan 

ZSCAN Redis command: iterates elements of Sorted Set types and their associated scores.

Definition at line 11 of file scan_tag.hpp.

◆ SetReply

enum class storages::redis::SetReply
strong

Definition at line 91 of file reply_types.hpp.

◆ StatusOk

enum class storages::redis::StatusOk
strong

Definition at line 93 of file reply_types.hpp.

◆ StatusPong

enum class storages::redis::StatusPong
strong

Definition at line 95 of file reply_types.hpp.

◆ WaitConnectedMode

Connection wait mode for the Redis.

Enumerator
kNoWait 

Do not wait.

kMaster 

If we need to write to redis.

kMasterOrSlave 

Enough for reading data from redis.

kSlave 

It may be no slaves on unstable. Waiting can always fail.

kMasterAndSlave 

It may be no slaves on unstable.

Definition at line 20 of file wait_connected_mode.hpp.

Function Documentation

◆ MakeBulkHedgedRedisRequest()

template<typename RedisRequestType , typename... Args, typename M = RedisRequestType (storages::redis::Client::*)(Args..., const redis::CommandControl&)>
std::vector< std::optional< typename RedisRequestType::Reply > > storages::redis::MakeBulkHedgedRedisRequest ( std::shared_ptr< storages::redis::Client > redis,
M method,
const redis::CommandControl & cc,
utils::hedging::HedgingSettings hedging_settings,
std::vector< std::tuple< Args... > > args )

Same as MakeHedgedRedisRequest but accepting a vector of argument tuples instead of a single set of arguments. And return vector of replies corresponding to input args.

< We do retries ourselves

Definition at line 129 of file hedged_request.hpp.

◆ MakeBulkHedgedRedisRequestAsync()

template<typename RedisRequestType , typename... Args, typename M = RedisRequestType (storages::redis::Client::*)(Args..., const redis::CommandControl&)>
utils::hedging::HedgedRequestBulkFuture< redis::impl::RedisRequestStrategy< RedisRequestType > > storages::redis::MakeBulkHedgedRedisRequestAsync ( std::shared_ptr< storages::redis::Client > redis,
M method,
const redis::CommandControl & cc,
utils::hedging::HedgingSettings hedging_settings,
std::vector< std::tuple< Args... > > args )

Same as MakeHedgedRedisRequestAsync but accepting a vector of argument tuples instead of a single set of arguments. And return vector of replies corresponding to input args.

< We do retries ourselves

Definition at line 163 of file hedged_request.hpp.

◆ MakeHedgedRedisRequest()

template<typename RedisRequestType , typename... Args, typename M = RedisRequestType (storages::redis::Client::*)(Args..., const redis::CommandControl&)>
std::optional< typename RedisRequestType::Reply > storages::redis::MakeHedgedRedisRequest ( std::shared_ptr< storages::redis::Client > redis,
M method,
const redis::CommandControl & cc,
utils::hedging::HedgingSettings hedging_settings,
Args... args )

< We do retries ourselves

Definition at line 101 of file hedged_request.hpp.

◆ MakeHedgedRedisRequestAsync()

template<typename RedisRequestType , typename... Args, typename M = RedisRequestType (storages::redis::Client::*)(Args..., const redis::CommandControl&)>
HedgedRedisRequest< RedisRequestType > storages::redis::MakeHedgedRedisRequestAsync ( std::shared_ptr< storages::redis::Client > redis,
M method,
const redis::CommandControl & cc,
utils::hedging::HedgingSettings hedging_settings,
Args... args )

< We do retries ourselves

Definition at line 73 of file hedged_request.hpp.

◆ operator|() [1/6]

constexpr ZaddOptions storages::redis::operator| ( ZaddOptions::Compare compare,
ZaddOptions::Exist exist )
constexpr

Definition at line 94 of file command_options.hpp.

◆ operator|() [2/6]

constexpr ZaddOptions storages::redis::operator| ( ZaddOptions::Compare compare,
ZaddOptions::ReturnValue return_value )
constexpr

Definition at line 95 of file command_options.hpp.

◆ operator|() [3/6]

constexpr ZaddOptions storages::redis::operator| ( ZaddOptions::Exist exist,
ZaddOptions::Compare compare )
constexpr

Definition at line 93 of file command_options.hpp.

◆ operator|() [4/6]

constexpr ZaddOptions storages::redis::operator| ( ZaddOptions::Exist exist,
ZaddOptions::ReturnValue return_value )
constexpr

Definition at line 90 of file command_options.hpp.

◆ operator|() [5/6]

constexpr ZaddOptions storages::redis::operator| ( ZaddOptions::ReturnValue return_value,
ZaddOptions::Compare compare )
constexpr

Definition at line 101 of file command_options.hpp.

◆ operator|() [6/6]

constexpr ZaddOptions storages::redis::operator| ( ZaddOptions::ReturnValue return_value,
ZaddOptions::Exist exist )
constexpr

Definition at line 98 of file command_options.hpp.

◆ Parse() [1/3]

template<typename Result , typename ReplyType = Result>
std::enable_if_t< impl::HasParseFunctionFromRedisReply< Result, ReplyType >::value, ReplyType > storages::redis::Parse ( ReplyData && reply_data,
const std::string & request_description,
To< Result, ReplyType >  )

Definition at line 103 of file parse_reply.hpp.

◆ Parse() [2/3]

template<typename T >
std::optional< T > storages::redis::Parse ( ReplyData && reply_data,
const std::string & request_description,
To< std::optional< T > >  )

Definition at line 114 of file parse_reply.hpp.

◆ Parse() [3/3]

template<typename T >
std::vector< T > storages::redis::Parse ( ReplyData && reply_data,
const std::string & request_description,
To< std::vector< T > >  )

Definition at line 108 of file parse_reply.hpp.

◆ ParseReply()

template<typename Result , typename ReplyType = Result>
ReplyType storages::redis::ParseReply ( ReplyPtr reply,
const std::string & request_description = {} )

Definition at line 120 of file parse_reply.hpp.

Variable Documentation

◆ kDefaultMaxRetries

constexpr std::size_t storages::redis::kDefaultMaxRetries {4}
inlineconstexpr

Definition at line 25 of file command_control.hpp.

◆ kDefaultTimeoutAll

constexpr std::chrono::milliseconds storages::redis::kDefaultTimeoutAll {2000}
inlineconstexpr

Definition at line 24 of file command_control.hpp.

◆ kDefaultTimeoutSingle

constexpr std::chrono::milliseconds storages::redis::kDefaultTimeoutSingle {500}
inlineconstexpr

Definition at line 23 of file command_control.hpp.

◆ kRedisWaitConnectedDefaultTimeout

constexpr auto storages::redis::kRedisWaitConnectedDefaultTimeout = std::chrono::seconds(11)
inlineconstexpr

Default timeout for Redis connection wait.

Definition at line 17 of file wait_connected_mode.hpp.

◆ kRetryNilFromMaster

constexpr RetryNilFromMaster storages::redis::kRetryNilFromMaster {}
inlineconstexpr

Can be used as an additional parameter in some commands to force retries to master if slave returned a nil reply.

Definition at line 73 of file command_control.hpp.