#include <redis_transaction.hpp>

类 acl::redis_transaction 继承关系图:

acl::redis_transaction 的协作图:

Public 成员函数
	redis_transaction (void)

	redis_transaction (redis_client *conn)

	redis_transaction (redis_client_cluster *cluster)

	redis_transaction (redis_client_pipeline *pipeline)

ACL_CPP_DEPRECATED	redis_transaction (redis_client_cluster *cluster, size_t max_conns)

virtual	~redis_transaction (void)

bool	watch (const std::vector< string > &keys)

bool	unwatch (void)

bool	multi (void)

bool	exec (void)

bool	discard (void)

bool	run_cmd (const char cmd, const char argv[], const size_t lens[], size_t argc)

bool	run_cmd (const char *cmd, const std::vector< string > &args)

size_t	get_size (void) const

const redis_result *	get_child (size_t i, string *cmd) const

const std::vector< string > &	get_commands (void) const

Public 成员函数继承自 acl::redis_command
	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 成员函数继承自 acl::redis_command
static void	build_request (size_t argc, const char *argv[], size_t lens[], string &out)

Protected 成员函数继承自 acl::redis_command
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 属性继承自 acl::redis_command
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_transaction.hpp 第 12 行定义.

构造及析构函数说明

◆ redis_transaction() [1/5]

acl::redis_transaction::redis_transaction ( void )

see redis_command::redis_command()

◆ redis_transaction() [2/5]

acl::redis_transaction::redis_transaction ( redis_client * conn )

see redis_command::redis_command(redis_client*)

◆ redis_transaction() [3/5]

acl::redis_transaction::redis_transaction ( redis_client_cluster * cluster )

see redis_command::redis_command(redis_client_cluster*)

◆ redis_transaction() [4/5]

acl::redis_transaction::redis_transaction ( redis_client_pipeline * pipeline )

◆ redis_transaction() [5/5]

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

◆ ~redis_transaction()

virtual acl::redis_transaction::~redis_transaction ( void )

virtual

成员函数说明

◆ discard()

bool acl::redis_transaction::discard ( void )

取消事务，放弃执行事务块内的所有命令，如果正在使用 WATCH 命令监视某个(或某些) key，那么取消所有监视，等同于执行命令 UNWATCH discard all commands issued after MULTI

返回: {bool}

◆ exec()

bool acl::redis_transaction::exec ( void )

执行所有事务块内的命令，假如某个(或某些) key 正处于 WATCH 命令的监视之下，且事务块中有和这个(或这些) key 相关的命令，那么 EXEC 命令只在这个(或这些) key 没有被其他命令所改动的情况下执行并生效，否则该事务被打断(abort)；在执行本条命令成功后，可以调用下面的 get_size()/get_child() 获得每条命令的操作结果 execute all commands issued after MULTI

返回: {bool} 操作是否成功 if success of this operation

◆ get_child()

const redis_result* acl::redis_transaction::get_child	(	size_t	i,
		string *	cmd
	)		const

获取指定下标的对应的命令的执行结果对象 get the result of the given subscript

参数

i	{size_t} 命令执行结果在结果数组中的下标 the given subscript
cmd	{string*} 该参数非空时存放对应的 redis 命令 if not NULL, it will store the command of the given subscript

返回: {const redis_result*} 执行某条命令的结果，当 i 越界时返回 NULL return the result of one command, NULL if i was out of bounds

◆ get_commands()

const std::vector<string>& acl::redis_transaction::get_commands ( void ) const

inline

获得当前事务所重的命令集合 get all the commands issued between MULTI and EXEC

返回: {const std::vector<string>&}

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

         {
                 return cmds_;
         }

◆ get_size()

size_t acl::redis_transaction::get_size ( void ) const

在成功调用 exec 后调用本函数获得操作结果数组的长度 get the result array's length after EXEC

返回: {size_t}

◆ multi()

bool acl::redis_transaction::multi ( void )

标记一个事务块的开始，事务块内的多条命令会按照先后顺序被放进一个队列当中，最后由 EXEC 命令原子性(atomic)地执行 mark the start of a transaction block

返回: {bool} 操作是否成功 if success of this operation

◆ run_cmd() [1/2]

bool acl::redis_transaction::run_cmd	(	const char *	cmd,
		const char *	argv[],
		const size_t	lens[],
		size_t	argc
	)

在 multi 和 exec 之间可多次调用本函数执行多条 redis 客户端命令 run one command between MULTI and EXEC

参数

cmd	{const char*} redis 命令 the command
argv	{const char* []} 参数数组 the args array associate with the command
lens	[const size_t []} 参数的长度数组 the length array of the args array
argc	{size_t} 参数数组的长度 the length of the array for args

返回: {bool} 操作是否成功 if successful

◆ run_cmd() [2/2]

bool acl::redis_transaction::run_cmd	(	const char *	cmd,
		const std::vector< string > &	args
	)

在 multi 和 exec 之间多次调用本函数执行多条 redis 客户端命令 run one command between MULTI and exec, this function can be called more than once

参数

cmd	{const char*} redis 命令 the redis command
args	{const std::vector<string>&} 参数数组 the args array for the command

返回: {bool} 操作是否成功 if successful

◆ unwatch()

bool acl::redis_transaction::unwatch ( void )

取消 WATCH 命令对所有 key 的监视 forget about all watched keys

返回: {bool} 操作是否成功 if success of this operation

◆ watch()

bool acl::redis_transaction::watch ( const std::vector< string > & keys )

监视一个(或多个) key ，如果在事务执行之前这个(或这些) key 被其他命令所改动，那么事务将被打断 watch the given keys to determine execution of the MULTI/EXEC block, before EXEC some of the given keys were changed outer, the transaction will break

参数

keys	{const std::vector<string>&} key 集合 the given keys collection

返回: {bool} 操作是否成功，即使 key 集合中的有 key 不存在也会返回成功 if success of this operation

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

include/acl_cpp/redis/redis_transaction.hpp

Public 成员函数

额外继承的成员函数

详细描述

构造及析构函数说明

◆ redis_transaction() [1/5]

◆ redis_transaction() [2/5]

◆ redis_transaction() [3/5]

◆ redis_transaction() [4/5]

◆ redis_transaction() [5/5]

◆ ~redis_transaction()

成员函数说明

◆ discard()

◆ exec()

◆ get_child()

◆ get_commands()

◆ get_size()

◆ multi()

◆ run_cmd() [1/2]

◆ run_cmd() [2/2]

◆ unwatch()

◆ watch()