#include <redis_zset.hpp>

类 acl::redis_zset 继承关系图:

acl::redis_zset 的协作图:

Public 成员函数
	redis_zset (void)

	redis_zset (redis_client *conn)

	redis_zset (redis_client_cluster *cluster)

	redis_zset (redis_client_pipeline *pipeline)

ACL_CPP_DEPRECATED	redis_zset (redis_client_cluster *cluster, size_t max_conns)

virtual	~redis_zset (void)

int	zadd (const char key, const std::map< string, double > &members, const std::vector< string > options=NULL)

int	zadd (const char *key, const std::vector< std::pair< string, double > > &members)

int	zadd (const char key, const std::vector< std::pair< const char , double > > &members)

int	zadd (const char *key, const std::vector< string > &members, const std::vector< double > &scores)

int	zadd (const char key, const std::vector< const char > &members, const std::vector< double > &scores)

int	zadd (const char key, const char members[], double scores[], size_t size)

int	zadd (const char key, const char members[], size_t members_len[], double scores[], size_t size)

int	zadd_with_ch_xx (const char *key, const std::map< string, double > &members)

int	zadd_with_ch_nx (const char *key, const std::map< string, double > &members)

bool	zadd_with_incr (const char key, const char member, size_t len, double score, double result=NULL, const char option=NULL)

bool	zadd_with_incr (const char key, const char member, double score, double result=NULL, const char option=NULL)

bool	zadd_with_incr_xx (const char key, const char member, double score, double *result=NULL)

bool	zadd_with_incr_nx (const char key, const char member, double score, double *result=NULL)

int	zcard (const char *key)

int	zcount (const char *key, double min, double max)

bool	zincrby (const char key, double inc, const char member, double *result=NULL)

bool	zincrby (const char key, double inc, const char member, size_t len, double *result=NULL)

int	zrange (const char key, int start, int stop, std::vector< string > result)

int	zrange_with_scores (const char *key, int start, int stop, std::vector< std::pair< string, double > > &out)

int	zrangebyscore (const char key, double min, double max, std::vector< string > out, const int offset=NULL, const int count=NULL)

int	zrangebyscore (const char key, const char min, const char max, std::vector< string > out, const int offset=NULL, const int count=NULL)

int	zrangebyscore_with_scores (const char key, double min, double max, std::vector< std::pair< string, double > > &out, const int offset=NULL, const int *count=NULL)

int	zrangebyscore_with_scores (const char key, const char min, const char max, std::vector< std::pair< string, double > > &out, const int offset=NULL, const int *count=NULL)

int	zrank (const char key, const char member, size_t len)

int	zrank (const char key, const char member)

int	zrem (const char key, const char first_member,...)

int	zrem (const char *key, const std::vector< string > &members)

int	zrem (const char key, const std::vector< const char > &members)

int	zrem (const char key, const char members[], const size_t lens[], size_t argc)

int	zremrangebyrank (const char *key, int start, int stop)

int	zremrangebyscore (const char *key, double min, double max)

int	zremrangebyscore (const char key, const char min, const char *max)

int	zrevrange (const char key, int start, int stop, std::vector< string > result)

int	zrevrange_with_scores (const char *key, int start, int stop, std::vector< std::pair< string, double > > &out)

int	zrevrangebyscore_with_scores (const char key, double min, double max, std::vector< std::pair< string, double > > &out, const int offset=NULL, const int *count=NULL)

int	zrevrangebyscore_with_scores (const char key, const char min, const char max, std::vector< std::pair< string, double > > &out, const int offset=NULL, const int *count=NULL)

int	zrevrank (const char key, const char member, size_t len)

int	zrevrank (const char key, const char member)

bool	zscore (const char key, const char member, size_t len, double &result)

bool	zscore (const char key, const char member, double &result)

int	zunionstore (const char dst, const std::map< string, double > &keys, const char aggregate="SUM")

int	zunionstore (const char dst, const std::vector< string > &keys, const std::vector< double > weights=NULL, const char *aggregate="SUM")

int	zinterstore (const char dst, const std::map< string, double > &keys, const char aggregate="SUM")

int	zinterstore (const char dst, const std::vector< string > &keys, const std::vector< double > weights=NULL, const char *aggregate="SUM")

int	zscan (const char key, int cursor, std::vector< std::pair< string, double > > &out, const char pattern=NULL, const size_t *count=NULL)

int	zrangebylex (const char key, const char min, const char max, std::vector< string > out, const int offset=NULL, const int count=NULL)

int	zlexcount (const char key, const char min, const char *max)

int	zremrangebylex (const char key, const char min, const char *max)

int	zpopmin (const char *key, std::vector< std::pair< string, double > > &out, size_t count=1)

int	zpopmax (const char *key, std::vector< std::pair< string, double > > &out, size_t count=1)

int	bzpopmin (const char key, size_t timeout, string &member, double score=NULL)

int	bzpopmax (const char key, size_t timeout, string &member, double score=NULL)

int	bzpopmin (const std::vector< string > &keys, size_t timeout, string &member, double *score=NULL)

int	bzpopmax (const std::vector< string > &keys, size_t timeout, string &member, double *score=NULL)

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_zset.hpp 第 13 行定义.

构造及析构函数说明

◆ redis_zset() [1/5]

acl::redis_zset::redis_zset ( void )

see redis_command::redis_command()

◆ redis_zset() [2/5]

acl::redis_zset::redis_zset ( redis_client * conn )

see redis_command::redis_command(redis_client*)

◆ redis_zset() [3/5]

acl::redis_zset::redis_zset ( redis_client_cluster * cluster )

see redis_command::redis_command(redis_client_cluster*)

◆ redis_zset() [4/5]

acl::redis_zset::redis_zset ( redis_client_pipeline * pipeline )

◆ redis_zset() [5/5]

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

◆ ~redis_zset()

virtual acl::redis_zset::~redis_zset ( void )

virtual

成员函数说明

◆ bzpopmax() [1/2]

int acl::redis_zset::bzpopmax	(	const char *	key,
		size_t	timeout,
		string &	member,
		double *	score = `NULL`
	)

◆ bzpopmax() [2/2]

int acl::redis_zset::bzpopmax	(	const std::vector< string > &	keys,
		size_t	timeout,
		string &	member,
		double *	score = `NULL`
	)

◆ bzpopmin() [1/2]

int acl::redis_zset::bzpopmin	(	const char *	key,
		size_t	timeout,
		string &	member,
		double *	score = `NULL`
	)

◆ bzpopmin() [2/2]

int acl::redis_zset::bzpopmin	(	const std::vector< string > &	keys,
		size_t	timeout,
		string &	member,
		double *	score = `NULL`
	)

◆ zadd() [1/7]

int acl::redis_zset::zadd	(	const char *	key,
		const std::map< string, double > &	members,
		const std::vector< string > *	options = `NULL`
	)

添加对应 key 的有序集 add one or more members to a sorted set, or update its score if it already exists

参数

key	{const char*} 有序集键值 the key of a sorted set
members	"分值-成员"集合 the set storing values and stores

返回: {int} 新成功添加的 "分值-成员" 对的数量 the number of elements added to the sorted set, not including elements already existing for which the score was updated 0：表示一个也未添加，可能因为该成员已经存在于有序集中 nothing was added to the sorted set -1：表示出错或 key 对象非有序集对象 error or it was not a sorted set by the key >0：新添加的成员数量 the number of elements added

◆ zadd() [2/7]

int acl::redis_zset::zadd	(	const char *	key,
		const std::vector< std::pair< string, double > > &	members
	)

◆ zadd() [3/7]

int acl::redis_zset::zadd	(	const char *	key,
		const std::vector< std::pair< const char *, double > > &	members
	)

◆ zadd() [4/7]

int acl::redis_zset::zadd	(	const char *	key,
		const std::vector< string > &	members,
		const std::vector< double > &	scores
	)

◆ zadd() [5/7]

int acl::redis_zset::zadd	(	const char *	key,
		const std::vector< const char * > &	members,
		const std::vector< double > &	scores
	)

◆ zadd() [6/7]

int acl::redis_zset::zadd	(	const char *	key,
		const char *	members[],
		double	scores[],
		size_t	size
	)

◆ zadd() [7/7]

int acl::redis_zset::zadd	(	const char *	key,
		const char *	members[],
		size_t	members_len[],
		double	scores[],
		size_t	size
	)

◆ zadd_with_ch_nx()

int acl::redis_zset::zadd_with_ch_nx	(	const char *	key,
		const std::map< string, double > &	members
	)

◆ zadd_with_ch_xx()

int acl::redis_zset::zadd_with_ch_xx	(	const char *	key,
		const std::map< string, double > &	members
	)

◆ zadd_with_incr() [1/2]

bool acl::redis_zset::zadd_with_incr	(	const char *	key,
		const char *	member,
		size_t	len,
		double	score,
		double *	result = `NULL`,
		const char *	option = `NULL`
	)

◆ zadd_with_incr() [2/2]

bool acl::redis_zset::zadd_with_incr	(	const char *	key,
		const char *	member,
		double	score,
		double *	result = `NULL`,
		const char *	option = `NULL`
	)

◆ zadd_with_incr_nx()

bool acl::redis_zset::zadd_with_incr_nx	(	const char *	key,
		const char *	member,
		double	score,
		double *	result = `NULL`
	)

◆ zadd_with_incr_xx()

bool acl::redis_zset::zadd_with_incr_xx	(	const char *	key,
		const char *	member,
		double	score,
		double *	result = `NULL`
	)

◆ zcard()

int acl::redis_zset::zcard ( const char * key )

获得相应键的有序集的成员数量 get the number of elements in a sorted set

参数

key	{const char*} 有序集键值 the key of a a sorted set

返回: {int} 一个键的有序集的成员数量 the number of elements of the sorted set 0：该键不存在 the key doesn't exist -1：出错或该键的数据对象不是有效的有序集对象 error or it wasn't a sorted set by the key >0：当前键值对应的数据对象中的成员个数 the number of elements in the sorted set

◆ zcount()

int acl::redis_zset::zcount	(	const char *	key,
		double	min,
		double	max
	)

获得 key 的有序集中指定分值区间的成员个数 get the number of elements in a sorted set with scores within the given values

参数

key	{const char*} 有序集键值 the key of a sorted set
min	{double} 最小分值 the min score specified
max	{double} 最大分值 the max socre specified

返回: {int} 符合条件的成员个数 the number of elements in specified score range 0：该键对应的有序集不存在或该 KEY 有序集的对应分值区间成员为空 nothing in the specified score range, or the key doesn't exist -1: 出错或该键的数据对象不是有效的有序集对象 error or it is not a sorted set by the key

◆ zincrby() [1/2]

bool acl::redis_zset::zincrby	(	const char *	key,
		double	inc,
		const char *	member,
		double *	result = `NULL`
	)

将 key 的有序集中的某个成员的分值加上增量 inc increase the score of a memeber in a sorted set

参数

key	{const char*} 有序集键值 the key of the sorted set
inc	{double} 增量值 the value to be increased
member	{const char*} 有序集中成员名 the specified memeber of a sorted set
result	{double*} 非空时存储结果值 if not null, it will store the score result after increment

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

◆ zincrby() [2/2]

bool acl::redis_zset::zincrby	(	const char *	key,
		double	inc,
		const char *	member,
		size_t	len,
		double *	result = `NULL`
	)

◆ zinterstore() [1/2]

int acl::redis_zset::zinterstore	(	const char *	dst,
		const std::map< string, double > &	keys,
		const char *	aggregate = `"SUM"`
	)

计算给定的一个或多个有序集的交集，其中给定 key 的数量必须以 numkeys 参数指定，并将该并集(结果集)储存到目标有序集; 默认情况下，结果集中某个成员的 score 值是所有给定集下该成员 score 值之和

返回: {int} 新保存到目标有序集的结果集中的元素(成员)数量

◆ zinterstore() [2/2]

int acl::redis_zset::zinterstore	(	const char *	dst,
		const std::vector< string > &	keys,
		const std::vector< double > *	weights = `NULL`,
		const char *	aggregate = `"SUM"`
	)

◆ zlexcount()

int acl::redis_zset::zlexcount	(	const char *	key,
		const char *	min,
		const char *	max
	)

于一个所有成员的分值都相同的有序集合键 key 来说，这个命令会返回该集合中，成员介于 min 和 max 范围内的元素数量

返回: {int} 符合条件的元素数量

◆ zpopmax()

int acl::redis_zset::zpopmax	(	const char *	key,
		std::vector< std::pair< string, double > > &	out,
		size_t	count = `1`
	)

◆ zpopmin()

int acl::redis_zset::zpopmin	(	const char *	key,
		std::vector< std::pair< string, double > > &	out,
		size_t	count = `1`
	)

◆ zrange()

int acl::redis_zset::zrange	(	const char *	key,
		int	start,
		int	stop,
		std::vector< string > *	result
	)

从 key 的有序集中获得指定位置区间的成员名列表，成员按分值递增方式排序 get the specified range memebers of a sorted set sotred at key

参数

key	{const char*} 有序集键值 the key of a sorted set
start	{int} 起始下标位置 the begin index of the sorted set
stop	{int} 结束下标位置（结果集同时含该位置） the end index of the sorted set
result	{std::vector<string>*} 非空时存储结果集，内部先调用 result.clear() 清除其中的元素 if not NULL, it will store the memebers result

返回: {int} 结果集中成员的数量 the number of memebers 0: 表示结果集为空或 key 不存在 the result is empty or the key doesn't exist -1: 表示出错或 key 对象非有序集对象 error or it's not a sorted set by the key >0: 结果集的数量 the number of the memebers result 注：对于下标位置，0 表示第一个成员，1 表示第二个成员；-1 表示最后一个成员， -2 表示倒数第二个成员，以此类推 Notice: about the index, element by index 0 is the first of the sorted set, element by index -1 is the last one.

操作成功后可以通过以下任一方式获得数据 when success, the result can be got by one of the below proccess: 1、在调用方法中传入非空的存储结果对象的地址 the most easily way is to set a non-NULL result parameter for this function 2、基类方法 get_value 获得指定下标的元素数据 get the specified subscript's element by redis_command::get_value 3、基类方法 get_child 获得指定下标的元素对象(redis_result），然后再通过 redis_result::argv_to_string 方法获得元素数据 redis_result::argv_to_string 方法获得元素数据 get redis_result object with the given subscript, and get the element by redis_result::argv_to_string 4、基类方法 get_result 方法取得总结果集对象 redis_result，然后再通过 redis_result::get_child 获得一个元素对象，然后再通过方式 2 中指定的方法获得该元素的数据 get redis_result object by redis_command::get_result, and get the first element by redis_result::get_child, then get the element by the way same as the way 2 above. 5、基类方法 get_children 获得结果元素数组对象，再通过 redis_result 中的方法 argv_to_string 从每一个元素对象中获得元素数据 get child array by redis_command::get_children, and get the element from one of redis_result array by argv_to_string

◆ zrange_with_scores()

int acl::redis_zset::zrange_with_scores	(	const char *	key,
		int	start,
		int	stop,
		std::vector< std::pair< string, double > > &	out
	)

从 key 的有序集中获得指定位置区间的成员名及分值列表，成员按分值递增方式排序

参数

key	{const char*} 有序集键值
start	{int} 起始下标位置
stop	{int} 结束下标位置（结果集同时含该位置）
out	存储 "成员名-分值对"结果集，内部先调用 out.clear()

返回: {int} 结果集中成员的数量 0: 表示结果集为空或 key 不存在 -1: 表示出错或 key 对象非有序集对象 >0: 结果集的数量注：对于下标位置，0 表示第一个成员，1 表示第二个成员；-1 表示最后一个成员， -2 表示倒数第二个成员，以此类推

◆ zrangebylex()

int acl::redis_zset::zrangebylex	(	const char *	key,
		const char *	min,
		const char *	max,
		std::vector< string > *	out,
		const int *	offset = `NULL`,
		const int *	count = `NULL`
	)

当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序（lexicographical ordering）来进行排序，而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的成员

参数

min	{const char*} 区间最小值
max	{const char*} 区间最大值
out	{std::vector<string>*} 非空时存储结果集
offset	{const int*} 非空时有效，从结果集中选取的下标起始值
count	{const int*} 非空时有效，从结果集中的指定下标位置起选取的数量

返回: {int} 结果集中成员的数量 0: 表示结果集为空或 key 不存在 -1: 表示出错或 key 对象非有序集对象 >0: 结果集的数量注：关于区间的选择规则如下： 1）合法的 min 和 max 参数必须包含 ( 或者 [ ，其中 ( 表示开区间（指定的值不会被包含在范围之内），而 [ 则表示闭区间（指定的值会被包含在范围之内） 2）特殊值 + 和 - 在 min 参数以及 max 参数中具有特殊的意义，其中 + 表示正无限，而 - 表示负无限。因此，向一个所有成员的分值都相同的有序集合发送命令 ZRANGEBYLEX <zset> - + ，命令将返回有序集合中的所有元素

◆ zrangebyscore() [1/2]

int acl::redis_zset::zrangebyscore	(	const char *	key,
		double	min,
		double	max,
		std::vector< string > *	out,
		const int *	offset = `NULL`,
		const int *	count = `NULL`
	)

返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max ) 的成员。有序集成员按 score 值递增(从小到大)次序排列

参数

key	{const char*} 有序集键值
min	{double} 最小分值
max	{double} 最大分值
out	{std::vector<string>*} 非空时存储“成员名”结果集
offset	{const int*} 非空时表示结果集的起始下标
count	{const int*} 非空时表示截取的结果集中成员个数

返回: {int} 结果集中成员的数量 0: 表示结果集为空或 key 不存在 -1: 表示出错或 key 对象非有序集对象 >0: 结果集的数量注：offset 和 count 必须同时为非空指针时才有效

操作成功后可以通过以下任一方式获得数据 1、在调用方法中传入非空的存储结果对象的地址 2、基类方法 get_value 获得指定下标的元素数据 3、基类方法 get_child 获得指定下标的元素对象(redis_result），然后再通过 redis_result::argv_to_string 方法获得元素数据 4、基类方法 get_result 方法取得总结果集对象 redis_result，然后再通过 redis_result::get_child 获得一个元素对象，然后再通过方式 2 中指定的方法获得该元素的数据 5、基类方法 get_children 获得结果元素数组对象，再通过 redis_result 中的方法 argv_to_string 从每一个元素对象中获得元素数据

◆ zrangebyscore() [2/2]

int acl::redis_zset::zrangebyscore	(	const char *	key,
		const char *	min,
		const char *	max,
		std::vector< string > *	out,
		const int *	offset = `NULL`,
		const int *	count = `NULL`
	)

返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max ) 的成员。有序集成员按 score 值递增(从小到大)次序排列

参数

key	{const char*} 有序集键值
min	{const char*} 以字符串表示最小分值
max	{const char*} 以字符串表示最大分值
out	{std::vector<string>*} 非空时存储“成员名”结果集
offset	{const int*} 非空时表示结果集的起始下标
count	{const int*} 非空时表示截取的结果集中成员个数

返回: {int} 结果集中成员的数量 0: 表示结果集为空或 key 不存在 -1: 表示出错或 key 对象非有序集对象 >0: 结果集的数量注： 1）offset 和 count 必须同时为非空指针时才有效 2）min 和 max 可以是 -inf 和 +inf 来表示无限区间 3）默认情况下，区间的取值使用闭区间 (小于等于或大于等于)，也可以通过给参数前增加 ( 符号来使用可选的开区间 (小于或大于)，如： 3.1）"ZRANGEBYSCORE zset (1 5" 返回所有符合条件 1 < score <= 5 的成员 3.2）"ZRANGEBYSCORE zset (5 (10" 返回所有符合条件 5 < score < 10 的成员

操作成功后可以通过以下任一方式获得数据 1、在调用方法中传入非空的存储结果对象的地址 2、基类方法 get_value 获得指定下标的元素数据 3、基类方法 get_child 获得指定下标的元素对象(redis_result），然后再通过 redis_result::argv_to_string 方法获得元素数据 4、基类方法 get_result 方法取得总结果集对象 redis_result，然后再通过 redis_result::get_child 获得一个元素对象，然后再通过方式 2 中指定的方法获得该元素的数据 5、基类方法 get_children 获得结果元素数组对象，再通过 redis_result 中的方法 argv_to_string 从每一个元素对象中获得元素数据

◆ zrangebyscore_with_scores() [1/2]

int acl::redis_zset::zrangebyscore_with_scores	(	const char *	key,
		double	min,
		double	max,
		std::vector< std::pair< string, double > > &	out,
		const int *	offset = `NULL`,
		const int *	count = `NULL`
	)

返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max ) 的成员及分值。有序集成员按 score 值递增(从小到大)次序排列；分值(min/max)使用浮点数表示

参数

out	存储结果集，内部先调用 out.clear()

返回: {int} 结果集中成员的数量

◆ zrangebyscore_with_scores() [2/2]

int acl::redis_zset::zrangebyscore_with_scores	(	const char *	key,
		const char *	min,
		const char *	max,
		std::vector< std::pair< string, double > > &	out,
		const int *	offset = `NULL`,
		const int *	count = `NULL`
	)

返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max ) 的成员及分值。有序集成员按 score 值递增(从小到大)次序排列；分值(min/max)使用字符串表示

参数

out	存储结果集，内部先调用 out.clear()

返回: {int} 结果集中成员的数量

◆ zrank() [1/2]

int acl::redis_zset::zrank	(	const char *	key,
		const char *	member,
		size_t	len
	)

返回有序集 key 中成员 member 的排名(下标从 0 开始）；其中有序集成员按 score 值递增(从小到大)顺序排列

参数

key	{const char*} 有序集键值
member	{const char*} 成员名
len	{size_t} member 的长度

返回: {int} 下标位置值，-1 – 出错，或 key 非有序集对象，或成员名不存在

◆ zrank() [2/2]

int acl::redis_zset::zrank	(	const char *	key,
		const char *	member
	)

◆ zrem() [1/4]

int acl::redis_zset::zrem	(	const char *	key,
		const char *	first_member,
			...
	)

从有序集中删除某个成员

参数

key	{const char*} 有序集键值
first_member	{const char*} 要删除的成员列表的第一个

返回: {int} 成功删除的成员的数量，-1 表示出错或该 key 非有序集对象， 0 表示该有序集不存在或成员不存在，> 0 表示成功删除的成员数量

◆ zrem() [2/4]

int acl::redis_zset::zrem	(	const char *	key,
		const std::vector< string > &	members
	)

◆ zrem() [3/4]

int acl::redis_zset::zrem	(	const char *	key,
		const std::vector< const char * > &	members
	)

◆ zrem() [4/4]

int acl::redis_zset::zrem	(	const char *	key,
		const char *	members[],
		const size_t	lens[],
		size_t	argc
	)

◆ zremrangebylex()

int acl::redis_zset::zremrangebylex	(	const char *	key,
		const char *	min,
		const char *	max
	)

对于一个所有成员的分值都相同的有序集合键 key 来说，这个命令会移除该集合中，成员介于 min 和 max 范围内的所有元素

返回: {int} 被移除的元素数量

◆ zremrangebyrank()

int acl::redis_zset::zremrangebyrank	(	const char *	key,
		int	start,
		int	stop
	)

移除有序集 key 中，指定排名(rank)区间内的所有成员；区间分别以下标参数 start 和 stop 指出，包含 start 和 stop 在内；下标参数 start 和 stop 都以 0 为底，也就是说，以 0 表示有序集第一个成员，以 1 表示有序集第二个成员，以此类推；也可以使用负数下标，以 -1 表示最后一个成员， -2 表示倒数第二个成员，以此类推

参数

key	{const char*} 有序集键值
start	{int} 起始下标位置（从 0 开始）
stop	{int} 结束下标位置

返回: {int} 被移除的成员数量 0：表示 key 不存在或移除的区间不存在 -1：表示出错或 key 不是有序集合对象键值

◆ zremrangebyscore() [1/2]

int acl::redis_zset::zremrangebyscore	(	const char *	key,
		double	min,
		double	max
	)

移除有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max ) 的成员；自版本2.1.6开始，score 值等于 min 或 max 的成员也可以不包括在内，详情请参见 ZRANGEBYSCORE 命令

参数

key	{const char*} 有序集键值
min	{double} 最小分值
max	{double} 最大分值

返回: {int} 成功删除的成员的数量，-1 表示出错或该 key 非有序集对象， 0 表示该有序集不存在或成员不存在，> 0 表示成功删除的成员数量

◆ zremrangebyscore() [2/2]

int acl::redis_zset::zremrangebyscore	(	const char *	key,
		const char *	min,
		const char *	max
	)

移除有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max ) 的成员；自版本2.1.6开始，score 值等于 min 或 max 的成员也可以不包括在内，详情请参见 ZRANGEBYSCORE 命令

参数

key	{const char*} 有序集键值
min	{const char*} 字符串形式的最小分值，意义参见：zrangebyscore 注释
max	{const char*} 字符串形式的最大分值

返回: {int} 成功删除的成员的数量，-1 表示出错或该 key 非有序集对象， 0 表示该有序集不存在或成员不存在，> 0 表示成功删除的成员数量

◆ zrevrange()

int acl::redis_zset::zrevrange	(	const char *	key,
		int	start,
		int	stop,
		std::vector< string > *	result
	)

从 key 的有序集中获得指定位置区间的成员名列表，成员按分值递减方式排序

参数

key	{const char*} 有序集键值
start	{int} 起始下标位置
stop	{int} 结束下标位置（结果集同时含该位置）
result	{std::vector<string>*} 非空时存储结果集注：对于下标位置，0 表示第一个成员，1 表示第二个成员；-1 表示最后一个成员， -2 表示倒数第二个成员，以此类推

返回: {int} 结果集数量，-1 表示出错

◆ zrevrange_with_scores()

int acl::redis_zset::zrevrange_with_scores	(	const char *	key,
		int	start,
		int	stop,
		std::vector< std::pair< string, double > > &	out
	)

从 key 的有序集中获得指定位置区间的成员名及分值列表，成员按分值递减方式排序

参数

key	{const char*} 有序集键值
start	{int} 起始下标位置
stop	{int} 结束下标位置（结果集同时含该位置）
out	存储 "成员名-分值对"结果集，内部先调用 out.clear() 注：对于下标位置，0 表示第一个成员，1 表示第二个成员；-1 表示最后一个成员， -2 表示倒数第二个成员，以此类推

返回: {int} 结果集数量，-1 表示出错

◆ zrevrangebyscore_with_scores() [1/2]

int acl::redis_zset::zrevrangebyscore_with_scores	(	const char *	key,
		double	min,
		double	max,
		std::vector< std::pair< string, double > > &	out,
		const int *	offset = `NULL`,
		const int *	count = `NULL`
	)

返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max ) 的成员。有序集成员按 score 值递8减(从小到大)次序排列

参数

key	{const char*} 有序集键值
min	{const char*} 以字符串表示最小分值
max	{const char*} 以字符串表示最大分值
out	{std::vector<string>*} 非空时存储“成员名”结果集
offset	{const int*} 非空时表示结果集的起始下标
count	{const int*} 非空时表示截取的结果集中成员个数

返回: {int} 结果集中成员的数量 0: 表示结果集为空或 key 不存在 -1: 表示出错或 key 对象非有序集对象 >0: 结果集的数量注： 1）offset 和 count 必须同时为非空指针时才有效 2）min 和 max 可以是 -inf 和 +inf 来表示无限区间 3）默认情况下，区间的取值使用闭区间 (小于等于或大于等于)，也可以通过给参数前增加 ( 符号来使用可选的开区间 (小于或大于)，如： 3.1）"ZRANGEBYSCORE zset (1 5" 返回所有符合条件 1 < score <= 5 的成员 3.2）"ZRANGEBYSCORE zset (5 (10" 返回所有符合条件 5 < score < 10 的成员返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max ) 的成员及分值。有序集成员按 score 值递减(从小到大)次序排列；分值(min/max)使用浮点数表示

参数

out	存储“分值-成员名”对的结果集，内部先调用 out.clear()
count	{const int*} 非空时表示截取的结果集中成员个数

◆ zrevrangebyscore_with_scores() [2/2]

int acl::redis_zset::zrevrangebyscore_with_scores	(	const char *	key,
		const char *	min,
		const char *	max,
		std::vector< std::pair< string, double > > &	out,
		const int *	offset = `NULL`,
		const int *	count = `NULL`
	)

◆ zrevrank() [1/2]

int acl::redis_zset::zrevrank	(	const char *	key,
		const char *	member,
		size_t	len
	)

返回有序集 key 中成员 member 的排名(下标从 0 开始)；其中有序集成员按 score 值递减(从大到小)排序

参数

key	{const char*} 有序集键值
member	{const char*} 成员名
len	{size_t} member 的长度

返回: {int} 下标位置值，-1 – 出错，或 key 非有序集对象，或成员名不存在

◆ zrevrank() [2/2]

int acl::redis_zset::zrevrank	(	const char *	key,
		const char *	member
	)

◆ zscan()

int acl::redis_zset::zscan	(	const char *	key,
		int	cursor,
		std::vector< std::pair< string, double > > &	out,
		const char *	pattern = `NULL`,
		const size_t *	count = `NULL`
	)

命令用于迭代有序集合中的元素（包括元素成员和元素分值）

参数

cursor	{int} 游标值，开始遍历时该值写 0
out	存储结果集，内部以追加方式将本次遍历结果集合添加进该数组中，为防止因总结果集过大导致该数组溢出，用户可在调用本函数前后清理该数组对象
pattern	{const char*} 匹配模式，glob 风格，非空时有效
count	{const size_t*} 限定的结果集数量，非空指针时有效

返回: {int} 下一个游标位置，含义如下： 0：遍历结束 -1: 出错 >0: 游标的下一个位置，即使这样，具体有多少结果还需要检查 out，因为有可能为空

◆ zscore() [1/2]

bool acl::redis_zset::zscore	(	const char *	key,
		const char *	member,
		size_t	len,
		double &	result
	)

获得有序集 key 中，成员 member 的 score 值

参数

key	{const char*} 有序集键值
member	{const char*} 成员名
len	{size_t} member 的长度
result	{double&} 存储分值结果

返回: {bool} 当不存在或出错时返回 false，否则返回 true

◆ zscore() [2/2]

bool acl::redis_zset::zscore	(	const char *	key,
		const char *	member,
		double &	result
	)

◆ zunionstore() [1/2]

int acl::redis_zset::zunionstore	(	const char *	dst,
		const std::map< string, double > &	keys,
		const char *	aggregate = `"SUM"`
	)

计算给定的一个或多个有序集的并集，其中给定 key 的数量必须以 numkeys 参数指定，并将该并集(结果集)储存到目标有序集; 默认情况下，结果集中某个成员的 score 值是所有给定集下该成员 score 值之和

参数

dst	{const char*} 目标有序集键值
keys	源有序集键值-权重集合；使用权重选项，可以为每个给定有序集分别指定一个乘法因子(multiplication factor)，每个给定有序集的所有成员的 score 值在传递给聚合函数(aggregation function)之前都要先乘以该有序集的因子；如果没有指定 WEIGHTS 选项，乘法因子默认设置为 1
aggregate	{const char*} 聚合方式，默认是 SUM 聚合方式，聚合方式如下： SUM: 将所有集合中某个成员的 score 值之和作为结果集中该成员的 score 值 MIN: 将所有集合中某个成员的最小 score 值作为结果集中该成员的 score 值 MAX: 将所有集合中某个成员的最大 score 值作为结果集中该成员的 score 值

返回: {int} 新保存到目标有序集的结果集中的元素(成员)数量，如果源有序集集合中存在相同的成员，则只新增一个成员；返回 -1 表示出错

◆ zunionstore() [2/2]

int acl::redis_zset::zunionstore	(	const char *	dst,
		const std::vector< string > &	keys,
		const std::vector< double > *	weights = `NULL`,
		const char *	aggregate = `"SUM"`
	)

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

include/acl_cpp/redis/redis_zset.hpp

Public 成员函数

额外继承的成员函数

详细描述

构造及析构函数说明

◆ redis_zset() [1/5]

◆ redis_zset() [2/5]

◆ redis_zset() [3/5]

◆ redis_zset() [4/5]

◆ redis_zset() [5/5]

◆ ~redis_zset()

成员函数说明

◆ bzpopmax() [1/2]

◆ bzpopmax() [2/2]

◆ bzpopmin() [1/2]

◆ bzpopmin() [2/2]

◆ zadd() [1/7]

◆ zadd() [2/7]

◆ zadd() [3/7]

◆ zadd() [4/7]

◆ zadd() [5/7]

◆ zadd() [6/7]

◆ zadd() [7/7]

◆ zadd_with_ch_nx()

◆ zadd_with_ch_xx()

◆ zadd_with_incr() [1/2]

◆ zadd_with_incr() [2/2]

◆ zadd_with_incr_nx()

◆ zadd_with_incr_xx()

◆ zcard()

◆ zcount()

◆ zincrby() [1/2]

◆ zincrby() [2/2]

◆ zinterstore() [1/2]

◆ zinterstore() [2/2]

◆ zlexcount()

◆ zpopmax()

◆ zpopmin()

◆ zrange()

◆ zrange_with_scores()

◆ zrangebylex()

◆ zrangebyscore() [1/2]

◆ zrangebyscore() [2/2]

◆ zrangebyscore_with_scores() [1/2]

◆ zrangebyscore_with_scores() [2/2]

◆ zrank() [1/2]

◆ zrank() [2/2]

◆ zrem() [1/4]

◆ zrem() [2/4]

◆ zrem() [3/4]

◆ zrem() [4/4]

◆ zremrangebylex()

◆ zremrangebyrank()

◆ zremrangebyscore() [1/2]

◆ zremrangebyscore() [2/2]

◆ zrevrange()

◆ zrevrange_with_scores()

◆ zrevrangebyscore_with_scores() [1/2]

◆ zrevrangebyscore_with_scores() [2/2]

◆ zrevrank() [1/2]

◆ zrevrank() [2/2]

◆ zscan()

◆ zscore() [1/2]

◆ zscore() [2/2]

◆ zunionstore() [1/2]

◆ zunionstore() [2/2]