#include <redis_command.hpp>

类 acl::redis_command 继承关系图:

acl::redis_command 的协作图:

Public 成员函数
	redis_command (void)

	redis_command (redis_client *conn)

	redis_command (redis_client_cluster *cluster)

ACL_CPP_DEPRECATED	redis_command (redis_client_cluster *cluster, size_t max_conns)

	redis_command (redis_client_pipeline *pipeline)

virtual	~redis_command (void)

void	set_check_addr (bool on)

void	clear (bool save_slot=false)

void	reset (bool save_slot=false)

void	set_client (redis_client *conn)

redis_client *	get_client (void) const

const char *	get_client_addr (void) const

void	set_cluster (redis_client_cluster *cluster)

ACL_CPP_DEPRECATED void	set_cluster (redis_client_cluster *cluster, size_t max_conns)

redis_client_cluster *	get_cluster (void) const

void	set_pipeline (redis_client_pipeline *pipeline, bool use_mbox=true)

redis_client_pipeline *	get_pipeline (void) const

dbuf_pool *	get_dbuf (void) const

redis_result_t	result_type (void) const

const char *	result_status (void) const

const char *	result_error (void) const

size_t	result_size (void) const

int	result_number (bool *success=NULL) const

long long int	result_number64 (bool *success=NULL) const

const char *	get_result (size_t i, size_t *len=NULL) const

bool	eof (void) const

const redis_result *	get_result (void) const

const redis_result *	result_child (size_t i) const

const char *	result_value (size_t i, size_t *len=NULL) const

void	set_slice_request (bool on)

void	set_slice_respond (bool on)

const redis_result *	request (size_t argc, const char *argv[], size_t lens[], size_t nchild=0)

const redis_result *	request (const std::vector< string > &args, size_t nchild=0)

const string *	request_buf (void) const

void	build_request (size_t argc, const char *argv[], size_t lens[])

void	hash_slot (const char *key)

void	hash_slot (const char *key, size_t len)

int	get_slot (void) const

bool	is_check_addr (void) const

const char *	get_addr (const char *info)

void	set_client_addr (const char *addr)

void	set_client_addr (redis_client &conn)

redis_request *	get_request_obj (void) const

string *	get_request_buf (void) const

bool	is_slice_req (void) const

redis_pipeline_message &	get_pipeline_message (void)

静态 Public 成员函数
static void	build_request (size_t argc, const char *argv[], size_t lens[], string &out)

Protected 成员函数
const redis_result *	run (size_t nchild=0, int *timeout=NULL)

void	clear_request (void)

const redis_result **	scan_keys (const char cmd, const char key, int &cursor, size_t &size, const char pattern, const size_t count)

const redis_result **	scan_keys (const char cmd, const char key, size_t klen, int &cursor, size_t &size, const char pattern, const size_t count)

void	build (const char cmd, const char key, const std::map< string, string > &attrs)

void	build (const char cmd, const char key, size_t klen, const std::map< string, string > &attrs)

void	build (const char cmd, const char key, const std::map< string, const char * > &attrs)

void	build (const char cmd, const char key, const std::vector< string > &names, const std::vector< string > &values)

void	build (const char cmd, const char key, size_t klen, const std::vector< string > &names, const std::vector< string > &values)

void	build (const char cmd, const char key, const std::vector< const char * > &names, const std::vector< const char * > &values)

void	build (const char cmd, const char key, const char names[], const char values[], size_t argc)

void	build (const char cmd, const char key, const int names[], const char *values[], size_t argc)

void	build (const char cmd, const char key, const char names[], const size_t names_len[], const char values[], const size_t values_len[], size_t argc)

void	build (const char cmd, const char key, size_t klen, const char names[], const size_t names_len[], const char values[], const size_t values_len[], size_t argc)

void	build (const char cmd, const char key, const std::vector< string > &names)

void	build (const char cmd, const char key, size_t klen, const std::vector< string > &names)

void	build (const char cmd, const char key, const std::vector< const char * > &names)

void	build (const char cmd, const char key, const std::vector< int > &names)

void	build (const char cmd, const char key, const char *names[], size_t argc)

void	build (const char cmd, const char key, const char *names[], const size_t lens[], size_t argc)

void	build (const char cmd, const char key, size_t klen, const char *names[], const size_t lens[], size_t argc)

void	build (const char cmd, const char key, const int names[], size_t argc)

int	get_number (bool *success=NULL)

long long int	get_number64 (bool *success=NULL)

int	get_number (std::vector< int > &out)

int	get_number64 (std::vector< long long int > &out)

bool	check_status (const char *success="OK")

int	get_status (std::vector< bool > &out)

const char *	get_status (void)

int	get_string (string &buf)

int	get_string (string *buf)

int	get_string (char *buf, size_t size)

int	get_strings (std::vector< string > &result)

int	get_strings (std::vector< string > *result)

int	get_strings (std::list< string > &result)

int	get_strings (std::list< string > *result)

int	get_strings (std::map< string, string > &result)

int	get_strings (std::vector< string > &names, std::vector< string > &values)

int	get_strings (std::vector< const char * > &names, std::vector< const char * > &values)

void	argv_space (size_t n)

void	build_request1 (size_t argc, const char *argv[], size_t lens[])

void	build_request2 (size_t argc, const char *argv[], size_t lens[])

void	logger_result (const redis_result *result)

Protected 成员函数继承自 acl::acl::noncopyable
	noncopyable ()

	~noncopyable ()

Protected 属性
dbuf_pool *	dbuf_

bool	check_addr_

char	addr_ [32]

redis_client *	conn_

redis_client_cluster *	cluster_

redis_client_pipeline *	pipeline_

bool	pipe_use_mbox_

int	slot_

int	redirect_max_

int	redirect_sleep_

bool	slice_req_

string *	request_buf_

redis_request *	request_obj_

size_t	argv_size_

const char **	argv_

size_t *	argv_lens_

size_t	argc_

bool	slice_res_

redis_pipeline_message *	pipe_msg_

const redis_result *	result_

详细描述

redis 客户端命令类的纯虚父类; the redis command classes's base virtual class, which includes the basic functions for all sub-classes

在文件 redis_command.hpp 第 26 行定义.

构造及析构函数说明

◆ redis_command() [1/5]

acl::redis_command::redis_command ( void )

缺省的构造函数，如果使用此构造函数初始化类对象，则必须调用 set_client 或 set_cluster 设置 redis 客户端命令类对象的通讯方式。 default constructor. You must set the communication method by set_client or set_cluster functions.

◆ redis_command() [2/5]

acl::redis_command::redis_command ( redis_client * conn )

当使用非集群模式时，可以使用此构造函数设置 redis 通信对象。 Using this constructor to set the redis communication mode, usually in no-cluster mode.

参数

conn	{redis_client*} redis 通信类对象 the redis communication in no-cluster mode

◆ redis_command() [3/5]

acl::redis_command::redis_command ( redis_client_cluster * cluster )

集群模式的构造函数，在构造类对象时指定了集群模式的 redis_client_cluster 对象。 Using this constructor to set the redis_client_cluster, usually in cluster mode.

参数

cluster {redis_client_cluster*} redis 集群连接对象 redis cluster object in cluster mode the max of every connection pool with all the redis nodes, if be set 0, then there is no connections limit in connections pool.

◆ redis_command() [4/5]

ACL_CPP_DEPRECATED acl::redis_command::redis_command	(	redis_client_cluster *	cluster,
		size_t	max_conns
	)

◆ redis_command() [5/5]

acl::redis_command::redis_command ( redis_client_pipeline * pipeline )

◆ ~redis_command()

virtual acl::redis_command::~redis_command ( void )

virtual

成员函数说明

◆ argv_space()

void acl::redis_command::argv_space ( size_t n )

protected

◆ build() [1/18]

void acl::redis_command::build	(	const char *	cmd,
		const char *	key,
		const std::map< string, string > &	attrs
	)

protected

◆ build() [2/18]

void acl::redis_command::build	(	const char *	cmd,
		const char *	key,
		size_t	klen,
		const std::map< string, string > &	attrs
	)

protected

◆ build() [3/18]

void acl::redis_command::build	(	const char *	cmd,
		const char *	key,
		const std::map< string, const char * > &	attrs
	)

protected

◆ build() [4/18]

void acl::redis_command::build	(	const char *	cmd,
		const char *	key,
		const std::vector< string > &	names,
		const std::vector< string > &	values
	)

protected

◆ build() [5/18]

void acl::redis_command::build	(	const char *	cmd,
		const char *	key,
		size_t	klen,
		const std::vector< string > &	names,
		const std::vector< string > &	values
	)

protected

◆ build() [6/18]

void acl::redis_command::build	(	const char *	cmd,
		const char *	key,
		const std::vector< const char * > &	names,
		const std::vector< const char * > &	values
	)

protected

◆ build() [7/18]

void acl::redis_command::build	(	const char *	cmd,
		const char *	key,
		const char *	names[],
		const char *	values[],
		size_t	argc
	)

protected

◆ build() [8/18]

void acl::redis_command::build	(	const char *	cmd,
		const char *	key,
		const int	names[],
		const char *	values[],
		size_t	argc
	)

protected

◆ build() [9/18]

void acl::redis_command::build	(	const char *	cmd,
		const char *	key,
		const char *	names[],
		const size_t	names_len[],
		const char *	values[],
		const size_t	values_len[],
		size_t	argc
	)

protected

◆ build() [10/18]

void acl::redis_command::build	(	const char *	cmd,
		const char *	key,
		size_t	klen,
		const char *	names[],
		const size_t	names_len[],
		const char *	values[],
		const size_t	values_len[],
		size_t	argc
	)

protected

◆ build() [11/18]

void acl::redis_command::build	(	const char *	cmd,
		const char *	key,
		const std::vector< string > &	names
	)

protected

◆ build() [12/18]

void acl::redis_command::build	(	const char *	cmd,
		const char *	key,
		size_t	klen,
		const std::vector< string > &	names
	)

protected

◆ build() [13/18]

void acl::redis_command::build	(	const char *	cmd,
		const char *	key,
		const std::vector< const char * > &	names
	)

protected

◆ build() [14/18]

void acl::redis_command::build	(	const char *	cmd,
		const char *	key,
		const std::vector< int > &	names
	)

protected

◆ build() [15/18]

void acl::redis_command::build	(	const char *	cmd,
		const char *	key,
		const char *	names[],
		size_t	argc
	)

protected

◆ build() [16/18]

void acl::redis_command::build	(	const char *	cmd,
		const char *	key,
		const char *	names[],
		const size_t	lens[],
		size_t	argc
	)

protected

◆ build() [17/18]

void acl::redis_command::build	(	const char *	cmd,
		const char *	key,
		size_t	klen,
		const char *	names[],
		const size_t	lens[],
		size_t	argc
	)

protected

◆ build() [18/18]

void acl::redis_command::build	(	const char *	cmd,
		const char *	key,
		const int	names[],
		size_t	argc
	)

protected

◆ build_request() [1/2]

static void acl::redis_command::build_request	(	size_t	argc,
		const char *	argv[],
		size_t	lens[],
		string &	out
	)

static

根据请求命令字列表创建 redis 请求协议数据

参数

argc	{size_t} 命令参数个数
argv	{const char* []} 命令参数数组
lens	{size_t []} 每个命令参数长度数组
out	{string&} 存放创建结果

◆ build_request() [2/2]

void acl::redis_command::build_request	(	size_t	argc,
		const char *	argv[],
		size_t	lens[]
	)

根据命令字列表创建 redis 请求协议并存储于 redis_command 中，以备在请求时使用

参数

argc	{size_t} 命令参数个数
argv	{const char* []} 命令参数数组
lens	{size_t []} 每个命令参数长度数组

◆ build_request1()

void acl::redis_command::build_request1	(	size_t	argc,
		const char *	argv[],
		size_t	lens[]
	)

protected

◆ build_request2()

void acl::redis_command::build_request2	(	size_t	argc,
		const char *	argv[],
		size_t	lens[]
	)

protected

◆ check_status()

bool acl::redis_command::check_status ( const char * success = "OK" )

protected

◆ clear()

void acl::redis_command::clear ( bool save_slot = false )

在重复使用一个继承于 redis_command 的子类操作 redis 时，需要在下一次调用前调用本方法以释放上次操作的临时对象; when reusing a redis command sub-class, the reset method should be called first to rlease some resources in last command operation

参数

save_slot {bool} 当采用集群模式时，该参数决定是否需要重新计算哈希槽值，如果反复调用 redis 命令过程中的 key 值不变，则可以保留此哈希槽值以减少内部重新进行计算的次数; when in cluster mode, if your operations is on the same key, you can set the param save_slot to false which can reduse the times of compute the same key's hash-slot.

◆ clear_request()

void acl::redis_command::clear_request ( void )

protected

◆ eof()

bool acl::redis_command::eof ( void ) const

判断当前所绑定的 redis 连接流对象(redis_client) 连接是否已经关闭；只有内部的 conn_ 流对象非空时调用此函数才有意义; to judge if the redis connection was be closed, only redis_client object be set internal

返回: {bool}

◆ get_addr()

const char* acl::redis_command::get_addr ( const char * info )

◆ get_client()

redis_client* acl::redis_command::get_client ( void ) const

inline

获得当前 redis 客户端命令的连接对象; get redis connection set by set_client function

返回: {redis_client*} 返回 NULL 表示没有连接对象与当前的命令对象进行绑定; the internal redis connection be returned, NULL if no redis connection be set

在文件 redis_command.hpp 第 108 行定义.

         {
                 return conn_;
         }

◆ get_client_addr()

const char* acl::redis_command::get_client_addr ( void ) const

获得当前 redis 命令对象所绑定的服务器地址，只有当该对象与 redis_client 绑定时（即调用 set_client) 才可以调用本函数 get the redis-server's addr used by the current command. this method can only be used only if the redis_client was set by set_client method.

返回: {const char*} 返回空串 "" 表示没有绑定 redis 连接对象 if "" was resturned, the redis connection was not set

◆ get_cluster()

redis_client_cluster* acl::redis_command::get_cluster ( void ) const

inline

获得所设置的连接池集群管理器; get redis_cluster object set by set_cluster function

返回: {redis_client_cluster*}

在文件 redis_command.hpp 第 143 行定义.

         {
                 return cluster_;
         }

◆ get_dbuf()

dbuf_pool* acl::redis_command::get_dbuf ( void ) const

inline

获得内存池句柄，该内存池由 redis_command 内部产生; get memory pool handle been set

返回: {dbuf_pool*}

在文件 redis_command.hpp 第 172 行定义.

         {
                 return dbuf_;
         }

◆ get_number() [1/2]

int acl::redis_command::get_number ( bool * success = NULL )

protected

◆ get_number() [2/2]

int acl::redis_command::get_number ( std::vector< int > & out )

protected

◆ get_number64() [1/2]

long long int acl::redis_command::get_number64 ( bool * success = NULL )

protected

◆ get_number64() [2/2]

int acl::redis_command::get_number64 ( std::vector< long long int > & out )

protected

◆ get_pipeline()

redis_client_pipeline* acl::redis_command::get_pipeline ( void ) const

inline

get the redis pipeline communication object been set before

返回: {redis_client_pipeline*} return NULL if not set

在文件 redis_command.hpp 第 162 行定义.

         {
                 return pipeline_;
         }

◆ get_pipeline_message()

redis_pipeline_message& acl::redis_command::get_pipeline_message ( void )

◆ get_request_buf()

string* acl::redis_command::get_request_buf ( void ) const

inline

在文件 redis_command.hpp 第 498 行定义.

                                             {
                 return request_buf_;
         }

◆ get_request_obj()

redis_request* acl::redis_command::get_request_obj ( void ) const

inline

在文件 redis_command.hpp 第 494 行定义.

                                                    {
                 return request_obj_;
         }

◆ get_result() [1/2]

const char* acl::redis_command::get_result	(	size_t	i,
		size_t *	len = `NULL`
	)		const

返回对应下标的数据(当数据类型非 REDIS_RESULT_ARRAY 时）; get string result when result type isn't REDIS_RESULT_ARRAY

参数

i	{size_t} 数组下标; the array index
len	{size_t} 当为非 NULL 指针时存储所返回数据的长度; len will save the result's length if len is not NULL

返回: {const char*} 返回 NULL 表示下标越界; NULL will return if i beyonds the array's size

◆ get_result() [2/2]

const redis_result* acl::redis_command::get_result ( void ) const

获得本次 redis 操作过程的结果; get result object of last redis operation

返回: {redis_result*}

◆ get_slot()

int acl::redis_command::get_slot ( void ) const

inline

在文件 redis_command.hpp 第 469 行定义.

                                  {
                 return slot_;
         }

◆ get_status() [1/2]

int acl::redis_command::get_status ( std::vector< bool > & out )

protected

◆ get_status() [2/2]

const char* acl::redis_command::get_status ( void )

protected

◆ get_string() [1/3]

int acl::redis_command::get_string ( string & buf )

protected

◆ get_string() [2/3]

int acl::redis_command::get_string ( string * buf )

protected

◆ get_string() [3/3]

int acl::redis_command::get_string	(	char *	buf,
		size_t	size
	)

protected

◆ get_strings() [1/7]

int acl::redis_command::get_strings ( std::vector< string > & result )

protected

◆ get_strings() [2/7]

int acl::redis_command::get_strings ( std::vector< string > * result )

protected

◆ get_strings() [3/7]

int acl::redis_command::get_strings ( std::list< string > & result )

protected

◆ get_strings() [4/7]

int acl::redis_command::get_strings ( std::list< string > * result )

protected

◆ get_strings() [5/7]

int acl::redis_command::get_strings ( std::map< string, string > & result )

protected

◆ get_strings() [6/7]

int acl::redis_command::get_strings	(	std::vector< string > &	names,
		std::vector< string > &	values
	)

protected

◆ get_strings() [7/7]

int acl::redis_command::get_strings	(	std::vector< const char * > &	names,
		std::vector< const char * > &	values
	)

protected

◆ hash_slot() [1/2]

void acl::redis_command::hash_slot ( const char * key )

◆ hash_slot() [2/2]

void acl::redis_command::hash_slot	(	const char *	key,
		size_t	len
	)

◆ is_check_addr()

bool acl::redis_command::is_check_addr ( void ) const

inline

在文件 redis_command.hpp 第 473 行定义.

                                        {
                 return check_addr_;
         }

◆ is_slice_req()

bool acl::redis_command::is_slice_req ( void ) const

inline

在文件 redis_command.hpp 第 502 行定义.

                                       {
                 return slice_req_;
         }

◆ logger_result()

void acl::redis_command::logger_result ( const redis_result * result )

protected

◆ request() [1/2]

const redis_result* acl::redis_command::request	(	size_t	argc,
		const char *	argv[],
		size_t	lens[],
		size_t	nchild = `0`
	)

直接组合 redis 协议命令方式，从 redis 服务器获得结果

参数

argc	{size_t} 后面数组中数组元素个数
argv	{const char*[]} redis 命令组成的数组
lens	{size_t[]} argv 中数组元素的长度
nchild	{size_t} 有的 redis 命令需要获取多个结果集，如：subop

返回: {const redis_result*} 返回的结果集

◆ request() [2/2]

const redis_result* acl::redis_command::request	(	const std::vector< string > &	args,
		size_t	nchild = `0`
	)

直接组合 redis 协议命令方式，从 redis 服务器获得结果

参数

args	{const std::vector<string>&} redis 命令组成的数组
nchild	{size_t} 有的 redis 命令需要获取多个结果集，如：subop

返回: {const redis_result*} 返回的结果集

◆ request_buf()

const string* acl::redis_command::request_buf ( void ) const

inline

在文件 redis_command.hpp 第 346 行定义.

         {
                 return request_buf_;
         }

◆ reset()

void acl::redis_command::reset ( bool save_slot = false )

◆ result_child()

const redis_result* acl::redis_command::result_child ( size_t i ) const

当查询结果为数组对象时调用本方法获得一个数组元素对象; get one result ojbect of array if result type is REDIS_RESULT_ARRAY

参数

i	{size_t} 数组对象的下标值; the result array's index

返回: {const redis_result*} 当结果非数组对象或结果为空或出错时该方法返回 NULL; NULL will be resturned when result is not REDIS_RESULT_ARRAY or array empty or error

◆ result_error()

const char* acl::redis_command::result_error ( void ) const

当出错时返回值为 REDIS_RESULT_ERROR 类型，本方法返回出错信息; when result type is REDIS_RESULT_ERROR, the error info can be get by this function

返回: {const char*} 返回空串 "" 表示没有出错信息; "" will be returned when no error info

◆ result_number()

int acl::redis_command::result_number ( bool * success = NULL ) const

当返回值为 REDIS_RESULT_INTEGER 类型时，本方法返回对应的 32 位整数值; get 32-bits number value if result type is REDIS_RESULT_INTERGER

参数

success {bool*} 本指针非 NULL 时记录操作过程是否成功; if the param pointer is not NULL, which will save status of success or not for result from redis-server

返回: {int}

◆ result_number64()

long long int acl::redis_command::result_number64 ( bool * success = NULL ) const

当返回值为 REDIS_RESULT_INTEGER 类型时，本方法返回对应的 64 位整数值; get 64-bits number value if result type is REDIS_RESULT_INTERGER

参数

success {bool*} 本指针非 NULL 时记录操作过程是否成功; if the param pointer is not NULL, which will save status of success or not for result from redis-server

返回: {long long int}

◆ result_size()

size_t acl::redis_command::result_size ( void ) const

获得当前结果结点存储的对象的个数, 该方法可以获得结果为下面两个方法 (result_child/result_value) 所需要的数组元素的个数; get number of result objects, just for functions result_child/result_value

返回: {size_t} 返回值与存储类型的对应关系如下： the relation between return value and result type, as below: REDIS_RESULT_ERROR: 1 REDIS_RESULT_STATUS: 1 REDIS_RESULT_INTEGER: 1 REDIS_RESULT_STRING: > 0 时表示该字符串数据被切分成非连接内存块的个数; when the result type is REDIS_RESULT_STRING and the the string is too large, the string was be cut into many small chunks, the returned value is the chunks number REDIS_RESULT_ARRAY: children_->size()

◆ result_status()

const char* acl::redis_command::result_status ( void ) const

当返回值为 REDIS_RESULT_STATUS 类型时，本方法返回状态信息; when result type is REDIS_RESULT_STATUS, the status info can be get by this function

返回: {const char*} 返回 "" 表示出错; "" will be returned on error

◆ result_type()

redis_result_t acl::redis_command::result_type ( void ) const

获得当前结果结点的数据类型; get the result type returned from redis-server

返回: {redis_result_t}

◆ result_value()

const char* acl::redis_command::result_value	(	size_t	i,
		size_t *	len = `NULL`
	)		const

当从 redis-server 获得的数据是一组字符串类型的结果集时，可以调用本函数获得某个指定下标位置的数据; when the reply from redis-serveer are strings array, this function can be used to get the string specified by a subscript

参数

i	{size_t} 下标（从 0 开始） the subscript of strings array
len	{size_t*} 若该指针非空，则存储所返回结果的长度（仅当该方法返回非空指针时有效） if len not a NULL pointer, it will store the length of string specified by the subscript

返回: {const char*} 返回对应下标的值，当返回 NULL 时表示该下标没有值，为了保证使用上的安全性，返回的数据总能保证最后是以 \0 结尾，在计算数据长度时不包含该结尾符，但为了兼容二进制情形，调用者还是应该通过返回的 len 存放的长度值来获得数据的真实长度 the string will be returned associate with the subscript, if there are nothing with the subscript, NULL will be returned

◆ run()

const redis_result* acl::redis_command::run	(	size_t	nchild = `0`,
		int *	timeout = `NULL`
	)

protected

◆ scan_keys() [1/2]

const redis_result** acl::redis_command::scan_keys	(	const char *	cmd,
		const char *	key,
		int &	cursor,
		size_t &	size,
		const char *	pattern,
		const size_t *	count
	)

protected

◆ scan_keys() [2/2]

const redis_result** acl::redis_command::scan_keys	(	const char *	cmd,
		const char *	key,
		size_t	klen,
		int &	cursor,
		size_t &	size,
		const char *	pattern,
		const size_t *	count
	)

protected

◆ set_check_addr()

void acl::redis_command::set_check_addr ( bool on )

在进行每个命令处理前，是否要求检查 socket 句柄与地址的匹配情况，当打开该选项时，将会严格检查匹配情况，但会影响一定性能，因此该设置仅用在 DEBUG 时的运行场景

参数

on {bool}

◆ set_client()

void acl::redis_command::set_client ( redis_client * conn )

在使用非集群方式时，通过本函数将从连接池获得的连接对象; when not using cluster mode, the function is used to set the connection for next redis command operation.

参数

conn	{redis_client*} 与 redis 客户端命令进行关联; the redis connection to be set in next redis operation

◆ set_client_addr() [1/2]

void acl::redis_command::set_client_addr ( const char * addr )

◆ set_client_addr() [2/2]

void acl::redis_command::set_client_addr ( redis_client & conn )

◆ set_cluster() [1/2]

void acl::redis_command::set_cluster ( redis_client_cluster * cluster )

设置连接池集群管理器; set the redis cluster object in redis cluster mode

参数

cluster {redis_client_cluster*} redis 集群连接对象; the redis_cluster connection object which can connect to any redis-server and support connection pool when dynamicly creating connection pool to any redis-server, use this param to limit the max number for each connection pool

◆ set_cluster() [2/2]

ACL_CPP_DEPRECATED void acl::redis_command::set_cluster	(	redis_client_cluster *	cluster,
		size_t	max_conns
	)

◆ set_pipeline()

void acl::redis_command::set_pipeline	(	redis_client_pipeline *	pipeline,
		bool	use_mbox = `true`
	)

设置pipeline通信对象，使用pipeline模式 set the redis communication in pipeline mode

参数

pipeline	{redis_client_pipeline*} pipeline communication object
use_mbox	{bool} if using acl::mbox to get the result, acl::tbox will be used if use_mbox is set to false; acl::mbox will be used as default internal.

◆ set_slice_request()

void acl::redis_command::set_slice_request ( bool on )

设置是否对请求数据进行分片处理，如果为 true 则内部在组装请求协议的时候不会将所有数据块重新组装成一个连续的大数据块 just for request package, setting flag for sending data with multi data chunks; this is useful when the request data is large

参数

on	{bool} 内部默认值为 false if true the request data will not be combined one package, internal default is false

◆ set_slice_respond()

void acl::redis_command::set_slice_respond ( bool on )

设置是否对响应数据进行分片处理，如果为 true 则当服务器的返回数据比较大时则将数据进行分片，分成一些不连续的数据块 just for response package, settint flag for receiving data if split the large response data into multi little chunks

参数

on	{bool} 内部默认值为 false if true the response data will be splitted into multi little data, which is useful for large reponse data for avoiding malloc large continuously memory from system. internal default is false

类成员变量说明

◆ addr_

char acl::redis_command::addr_[32]

protected

在文件 redis_command.hpp 第 479 行定义.

◆ argc_

size_t acl::redis_command::argc_

protected

在文件 redis_command.hpp 第 517 行定义.

◆ argv_

const char** acl::redis_command::argv_

protected

在文件 redis_command.hpp 第 515 行定义.

◆ argv_lens_

size_t* acl::redis_command::argv_lens_

protected

在文件 redis_command.hpp 第 516 行定义.

◆ argv_size_

size_t acl::redis_command::argv_size_

protected

在文件 redis_command.hpp 第 514 行定义.

◆ check_addr_

bool acl::redis_command::check_addr_

protected

在文件 redis_command.hpp 第 478 行定义.

◆ cluster_

redis_client_cluster* acl::redis_command::cluster_

protected

在文件 redis_command.hpp 第 481 行定义.

◆ conn_

redis_client* acl::redis_command::conn_

protected

在文件 redis_command.hpp 第 480 行定义.

◆ dbuf_

dbuf_pool* acl::redis_command::dbuf_

protected

在文件 redis_command.hpp 第 457 行定义.

◆ pipe_msg_

redis_pipeline_message* acl::redis_command::pipe_msg_

protected

在文件 redis_command.hpp 第 531 行定义.

◆ pipe_use_mbox_

bool acl::redis_command::pipe_use_mbox_

protected

在文件 redis_command.hpp 第 483 行定义.

◆ pipeline_

redis_client_pipeline* acl::redis_command::pipeline_

protected

在文件 redis_command.hpp 第 482 行定义.

◆ redirect_max_

int acl::redis_command::redirect_max_

protected

在文件 redis_command.hpp 第 485 行定义.

◆ redirect_sleep_

int acl::redis_command::redirect_sleep_

protected

在文件 redis_command.hpp 第 486 行定义.

◆ request_buf_

string* acl::redis_command::request_buf_

protected

在文件 redis_command.hpp 第 512 行定义.

◆ request_obj_

redis_request* acl::redis_command::request_obj_

protected

在文件 redis_command.hpp 第 513 行定义.

◆ result_

const redis_result* acl::redis_command::result_

protected

在文件 redis_command.hpp 第 532 行定义.

◆ slice_req_

bool acl::redis_command::slice_req_

protected

在文件 redis_command.hpp 第 511 行定义.

◆ slice_res_

bool acl::redis_command::slice_res_

protected

在文件 redis_command.hpp 第 530 行定义.

◆ slot_

int acl::redis_command::slot_

protected

在文件 redis_command.hpp 第 484 行定义.

该类的文档由以下文件生成:

include/acl_cpp/redis/redis_command.hpp

Public 成员函数

静态 Public 成员函数

Protected 成员函数

Protected 属性

详细描述

构造及析构函数说明

◆ redis_command() [1/5]

◆ redis_command() [2/5]

◆ redis_command() [3/5]

◆ redis_command() [4/5]

◆ redis_command() [5/5]

◆ ~redis_command()

成员函数说明

◆ argv_space()

◆ build() [1/18]

◆ build() [2/18]

◆ build() [3/18]

◆ build() [4/18]

◆ build() [5/18]

◆ build() [6/18]

◆ build() [7/18]

◆ build() [8/18]

◆ build() [9/18]

◆ build() [10/18]

◆ build() [11/18]

◆ build() [12/18]

◆ build() [13/18]

◆ build() [14/18]

◆ build() [15/18]

◆ build() [16/18]

◆ build() [17/18]

◆ build() [18/18]

◆ build_request() [1/2]

◆ build_request() [2/2]

◆ build_request1()

◆ build_request2()

◆ check_status()

◆ clear()

◆ clear_request()

◆ eof()

◆ get_addr()

◆ get_client()

◆ get_client_addr()

◆ get_cluster()

◆ get_dbuf()

◆ get_number() [1/2]

◆ get_number() [2/2]

◆ get_number64() [1/2]

◆ get_number64() [2/2]

◆ get_pipeline()

◆ get_pipeline_message()

◆ get_request_buf()

◆ get_request_obj()

◆ get_result() [1/2]

◆ get_result() [2/2]

◆ get_slot()

◆ get_status() [1/2]

◆ get_status() [2/2]

◆ get_string() [1/3]

◆ get_string() [2/3]

◆ get_string() [3/3]

◆ get_strings() [1/7]

◆ get_strings() [2/7]

◆ get_strings() [3/7]

◆ get_strings() [4/7]

◆ get_strings() [5/7]

◆ get_strings() [6/7]

◆ get_strings() [7/7]

◆ hash_slot() [1/2]

◆ hash_slot() [2/2]

◆ is_check_addr()

◆ is_slice_req()

◆ logger_result()

◆ request() [1/2]

◆ request() [2/2]

◆ request_buf()

◆ reset()

◆ result_child()

◆ result_error()

◆ result_number()