mirror of
https://gitee.com/acl-dev/acl.git
synced 2024-12-05 05:18:53 +08:00
573 lines
24 KiB
C++
573 lines
24 KiB
C++
#pragma once
|
||
#include "../acl_cpp_define.hpp"
|
||
#include <vector>
|
||
#include <map>
|
||
#include <utility>
|
||
#include "redis_command.hpp"
|
||
|
||
#if !defined(ACL_CLIENT_ONLY) && !defined(ACL_REDIS_DISABLE)
|
||
|
||
namespace acl
|
||
{
|
||
|
||
class redis_client;
|
||
|
||
class ACL_CPP_API redis_zset : virtual public redis_command
|
||
{
|
||
public:
|
||
/**
|
||
* see redis_command::redis_command()
|
||
*/
|
||
redis_zset(void);
|
||
|
||
/**
|
||
* see redis_command::redis_command(redis_client*)
|
||
*/
|
||
redis_zset(redis_client* conn);
|
||
|
||
/**
|
||
* see redis_command::redis_command(redis_client_cluster*, size_t)
|
||
*/
|
||
redis_zset(redis_client_cluster* cluster, size_t max_conns = 0);
|
||
virtual ~redis_zset(void);
|
||
|
||
/////////////////////////////////////////////////////////////////////
|
||
|
||
/**
|
||
* 添加对应 key 的有序集
|
||
* add one or more members to a sorted set, or update its score if
|
||
* it already exists
|
||
* @param key {const char*} 有序集键值
|
||
* the key of a sorted set
|
||
* @param members "分值-成员"集合
|
||
* the set storing values and stores
|
||
* @return {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
|
||
*/
|
||
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);
|
||
|
||
/**
|
||
* 获得相应键的有序集的成员数量
|
||
* get the number of elements in a sorted set
|
||
* @param key {const char*} 有序集键值
|
||
* the key of a a sorted set
|
||
* @return {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
|
||
*/
|
||
int zcard(const char* key);
|
||
|
||
/**
|
||
* 获得 key 的有序集中指定分值区间的成员个数
|
||
* get the number of elements in a sorted set with scores within
|
||
* the given values
|
||
* @param key {const char*} 有序集键值
|
||
* the key of a sorted set
|
||
* @param min {double} 最小分值
|
||
* the min score specified
|
||
* @param max {double} 最大分值
|
||
* the max socre specified
|
||
* @return {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
|
||
*/
|
||
int zcount(const char* key, double min, double max);
|
||
|
||
/**
|
||
* 将 key 的有序集中的某个成员的分值加上增量 inc
|
||
* increase the score of a memeber in a sorted set
|
||
* @param key {const char*} 有序集键值
|
||
* the key of the sorted set
|
||
* @param inc {double} 增量值
|
||
* the value to be increased
|
||
* @param member {const char*} 有序集中成员名
|
||
* the specified memeber of a sorted set
|
||
* @param result {double*} 非空时存储结果值
|
||
* if not null, it will store the score result after increment
|
||
* @return {bool} 操作是否成功
|
||
* if successful about the operation
|
||
*/
|
||
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);
|
||
|
||
/**
|
||
* 从 key 的有序集中获得指定位置区间的成员名列表，成员按分值递增方式排序
|
||
* get the specified range memebers of a sorted set sotred at key
|
||
* @param key {const char*} 有序集键值
|
||
* the key of a sorted set
|
||
* @param start {int} 起始下标位置
|
||
* the begin index of the sorted set
|
||
* @param stop {int} 结束下标位置（结果集同时含该位置）
|
||
* the end index of the sorted set
|
||
* @param result {std::vector<string>*} 非空时存储结果集，内部先调用
|
||
* result.clear() 清除其中的元素
|
||
* if not NULL, it will store the memebers result
|
||
* @return {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
|
||
*/
|
||
int zrange(const char* key, int start, int stop,
|
||
std::vector<string>* result);
|
||
|
||
/**
|
||
* 从 key 的有序集中获得指定位置区间的成员名及分值列表，成员按分值递增方式排序
|
||
* @param key {const char*} 有序集键值
|
||
* @param start {int} 起始下标位置
|
||
* @param stop {int} 结束下标位置（结果集同时含该位置）
|
||
* @param out 存储 "成员名-分值对"结果集，内部先调用 out.clear()
|
||
* @return {int} 结果集中成员的数量
|
||
* 0: 表示结果集为空或 key 不存在
|
||
* -1: 表示出错或 key 对象非有序集对象
|
||
* >0: 结果集的数量
|
||
* 注：对于下标位置，0 表示第一个成员，1 表示第二个成员；-1 表示最后一个成员，
|
||
* -2 表示倒数第二个成员，以此类推
|
||
*/
|
||
int zrange_with_scores(const char* key, int start, int stop,
|
||
std::vector<std::pair<string, double> >& out);
|
||
|
||
/**
|
||
* 返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )
|
||
* 的成员。有序集成员按 score 值递增(从小到大)次序排列
|
||
* @param key {const char*} 有序集键值
|
||
* @param min {double} 最小分值
|
||
* @param max {double} 最大分值
|
||
* @param out {std::vector<string>*} 非空时存储“成员名”结果集
|
||
* @param offset {const int*} 非空时表示结果集的起始下标
|
||
* @param count {const int*} 非空时表示截取的结果集中成员个数
|
||
* @return {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 从每一个元素对象中获得元素数据
|
||
*/
|
||
int 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 值递增(从小到大)次序排列
|
||
* @param key {const char*} 有序集键值
|
||
* @param min {const char*} 以字符串表示最小分值
|
||
* @param max {const char*} 以字符串表示最大分值
|
||
* @param out {std::vector<string>*} 非空时存储“成员名”结果集
|
||
* @param offset {const int*} 非空时表示结果集的起始下标
|
||
* @param count {const int*} 非空时表示截取的结果集中成员个数
|
||
* @return {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 从每一个元素对象中获得元素数据
|
||
*/
|
||
int 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 值递增(从小到大)次序排列；分值(min/max)使用
|
||
* 浮点数表示
|
||
* @param out 存储结果集，内部先调用 out.clear()
|
||
* @return {int} 结果集中成员的数量
|
||
*/
|
||
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);
|
||
|
||
/**
|
||
* 返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )
|
||
* 的成员及分值。有序集成员按 score 值递增(从小到大)次序排列；分值(min/max)使用
|
||
* 字符串表示
|
||
* @param out 存储结果集，内部先调用 out.clear()
|
||
* @return {int} 结果集中成员的数量
|
||
*/
|
||
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);
|
||
|
||
/**
|
||
* 返回有序集 key 中成员 member 的排名(下标从 0 开始）；其中有序集成员按 score
|
||
* 值递增(从小到大)顺序排列
|
||
* @param key {const char*} 有序集键值
|
||
* @param member {const char*} 成员名
|
||
* @param len {size_t} member 的长度
|
||
* @return {int} 下标位置值，-1 -- 出错，或 key 非有序集对象，或成员名不存在
|
||
*/
|
||
int zrank(const char* key, const char* member, size_t len);
|
||
int zrank(const char* key, const char* member);
|
||
|
||
/**
|
||
* 从有序集中删除某个成员
|
||
* @param key {const char*} 有序集键值
|
||
* @param first_member {const char*} 要删除的成员列表的第一个
|
||
* @return {int} 成功删除的成员的数量，-1 表示出错或该 key 非有序集对象，
|
||
* 0 表示该有序集不存在或成员不存在，> 0 表示成功删除的成员数量
|
||
*/
|
||
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);
|
||
|
||
/**
|
||
* 移除有序集 key 中，指定排名(rank)区间内的所有成员；
|
||
* 区间分别以下标参数 start 和 stop 指出，包含 start 和 stop 在内；
|
||
* 下标参数 start 和 stop 都以 0 为底，也就是说，以 0 表示有序集第一个成员，
|
||
* 以 1 表示有序集第二个成员，以此类推；
|
||
* 也可以使用负数下标，以 -1 表示最后一个成员， -2 表示倒数第二个成员，以此类推
|
||
* @param key {const char*} 有序集键值
|
||
* @param start {int} 起始下标位置（从 0 开始）
|
||
* @param stop {int} 结束下标位置
|
||
* @return {int} 被移除的成员数量
|
||
* 0：表示 key 不存在或移除的区间不存在
|
||
* -1：表示出错或 key 不是有序集合对象键值
|
||
*/
|
||
int zremrangebyrank(const char* key, int start, int stop);
|
||
|
||
/**
|
||
* 移除有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )
|
||
* 的成员；自版本2.1.6开始，score 值等于 min 或 max 的成员也可以不包括在内，
|
||
* 详情请参见 ZRANGEBYSCORE 命令
|
||
* @param key {const char*} 有序集键值
|
||
* @param min {double} 最小分值
|
||
* @param max {double} 最大分值
|
||
* @return {int} 成功删除的成员的数量，-1 表示出错或该 key 非有序集对象，
|
||
* 0 表示该有序集不存在或成员不存在，> 0 表示成功删除的成员数量
|
||
*/
|
||
int zremrangebyscore(const char* key, double min, double max);
|
||
|
||
/**
|
||
* 移除有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )
|
||
* 的成员；自版本2.1.6开始，score 值等于 min 或 max 的成员也可以不包括在内，
|
||
* 详情请参见 ZRANGEBYSCORE 命令
|
||
* @param key {const char*} 有序集键值
|
||
* @param min {const char*} 字符串形式的最小分值，意义参见：zrangebyscore 注释
|
||
* @param max {const char*} 字符串形式的最大分值
|
||
* @return {int} 成功删除的成员的数量，-1 表示出错或该 key 非有序集对象，
|
||
* 0 表示该有序集不存在或成员不存在，> 0 表示成功删除的成员数量
|
||
*/
|
||
int zremrangebyscore(const char* key, const char* min, const char* max);
|
||
|
||
/**
|
||
* 从 key 的有序集中获得指定位置区间的成员名列表，成员按分值递减方式排序
|
||
* @param key {const char*} 有序集键值
|
||
* @param start {int} 起始下标位置
|
||
* @param stop {int} 结束下标位置（结果集同时含该位置）
|
||
* @param result {std::vector<string>*} 非空时存储结果集
|
||
* 注：对于下标位置，0 表示第一个成员，1 表示第二个成员；-1 表示最后一个成员，
|
||
* -2 表示倒数第二个成员，以此类推
|
||
* @return {int} 结果集数量，-1 表示出错
|
||
*/
|
||
int zrevrange(const char* key, int start, int stop,
|
||
std::vector<string>* result);
|
||
|
||
/**
|
||
* 从 key 的有序集中获得指定位置区间的成员名及分值列表，成员按分值递减方式排序
|
||
* @param key {const char*} 有序集键值
|
||
* @param start {int} 起始下标位置
|
||
* @param stop {int} 结束下标位置（结果集同时含该位置）
|
||
* @param out 存储 "成员名-分值对"结果集，内部先调用 out.clear()
|
||
* 注：对于下标位置，0 表示第一个成员，1 表示第二个成员；-1 表示最后一个成员，
|
||
* -2 表示倒数第二个成员，以此类推
|
||
* @return {int} 结果集数量，-1 表示出错
|
||
*/
|
||
int zrevrange_with_scores(const char* key, int start, int stop,
|
||
std::vector<std::pair<string, double> >& out);
|
||
|
||
/**
|
||
* 返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )
|
||
* 的成员。有序集成员按 score 值递8减(从小到大)次序排列
|
||
* @param key {const char*} 有序集键值
|
||
* @param min {const char*} 以字符串表示最小分值
|
||
* @param max {const char*} 以字符串表示最大分值
|
||
* @param out {std::vector<string>*} 非空时存储“成员名”结果集
|
||
* @param offset {const int*} 非空时表示结果集的起始下标
|
||
* @param count {const int*} 非空时表示截取的结果集中成员个数
|
||
* @return {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 的成员
|
||
*/
|
||
//int zrevrangebyscore(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 值递减(从小到大)次序排列；分值(min/max)使用
|
||
* 浮点数表示
|
||
* @param out 存储“分值-成员名”对的结果集，内部先调用 out.clear()
|
||
* @param count {const int*} 非空时表示截取的结果集中成员个数
|
||
*/
|
||
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);
|
||
|
||
/**
|
||
* 返回有序集 key 中成员 member 的排名(下标从 0 开始)；其中有序集成员按 score
|
||
* 值递减(从大到小)排序
|
||
* @param key {const char*} 有序集键值
|
||
* @param member {const char*} 成员名
|
||
* @param len {size_t} member 的长度
|
||
* @return {int} 下标位置值，-1 -- 出错，或 key 非有序集对象，或成员名不存在
|
||
*/
|
||
int zrevrank(const char* key, const char* member, size_t len);
|
||
int zrevrank(const char* key, const char* member);
|
||
|
||
/**
|
||
* 获得有序集 key 中，成员 member 的 score 值
|
||
* @param key {const char*} 有序集键值
|
||
* @param member {const char*} 成员名
|
||
* @param len {size_t} member 的长度
|
||
* @param result {double&} 存储分值结果
|
||
* @return {bool} 当不存在或出错时返回 false，否则返回 true
|
||
*/
|
||
bool zscore(const char* key, const char* member, size_t len,
|
||
double& result);
|
||
bool zscore(const char* key, const char* member, double& result);
|
||
|
||
/**
|
||
* 计算给定的一个或多个有序集的并集，其中给定 key 的数量必须以 numkeys 参数指定，
|
||
* 并将该并集(结果集)储存到目标有序集; 默认情况下，结果集中某个成员的 score
|
||
* 值是所有给定集下该成员 score 值之和
|
||
* @param dst {const char*} 目标有序集键值
|
||
* @param keys 源有序集键值-权重集合；使用权重选项，可以为 每个 给定有序集 分别
|
||
* 指定一个乘法因子(multiplication factor)，每个给定有序集的所有成员的 score
|
||
* 值在传递给聚合函数(aggregation function)之前都要先乘以该有序集的因子；
|
||
* 如果没有指定 WEIGHTS 选项，乘法因子默认设置为 1
|
||
* @param aggregate {const char*} 聚合方式，默认是 SUM 聚合方式，聚合方式如下：
|
||
* SUM: 将所有集合中某个成员的 score 值之 和 作为结果集中该成员的 score 值
|
||
* MIN: 将所有集合中某个成员的 最小 score 值作为结果集中该成员的 score 值
|
||
* MAX: 将所有集合中某个成员的 最大 score 值作为结果集中该成员的 score 值
|
||
* @return {int} 新保存到目标有序集的结果集中的元素(成员)数量，如果源有序集
|
||
* 集合中存在相同的成员，则只新增一个成员；返回 -1 表示出错
|
||
*/
|
||
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");
|
||
|
||
/**
|
||
* 计算给定的一个或多个有序集的交集，其中给定 key 的数量必须以 numkeys 参数指定，
|
||
* 并将该并集(结果集)储存到目标有序集; 默认情况下，结果集中某个成员的 score
|
||
* 值是所有给定集下该成员 score 值之和
|
||
* @return {int} 新保存到目标有序集的结果集中的元素(成员)数量
|
||
*/
|
||
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");
|
||
|
||
/**
|
||
* 命令用于迭代有序集合中的元素（包括元素成员和元素分值）
|
||
* @param cursor {int} 游标值，开始遍历时该值写 0
|
||
* @param out 存储结果集，内部以追加方式将本次遍历结果集合添加进该数组中，
|
||
* 为防止因总结果集过大导致该数组溢出，用户可在调用本函数前后清理该数组对象
|
||
* @param pattern {const char*} 匹配模式，glob 风格，非空时有效
|
||
* @param count {const size_t*} 限定的结果集数量，非空指针时有效
|
||
* @return {int} 下一个游标位置，含义如下：
|
||
* 0：遍历结束
|
||
* -1: 出错
|
||
* >0: 游标的下一个位置，即使这样，具体有多少结果还需要检查 out，因为有可能为空
|
||
*/
|
||
int zscan(const char* key, int cursor,
|
||
std::vector<std::pair<string, double> >& out,
|
||
const char* pattern = NULL, const size_t* count = NULL);
|
||
|
||
/**
|
||
* 当有序集合的所有成员都具有相同的分值时， 有序集合的元素会根据成员的字典序
|
||
* （lexicographical ordering）来进行排序， 而这个命令则可以返回给定的
|
||
* 有序集合键 key 中， 值介于 min 和 max 之间的成员
|
||
* @param min {const char*} 区间最小值
|
||
* @param max {const char*} 区间最大值
|
||
* @param out {std::vector<string>*} 非空时存储结果集
|
||
* @param offset {const int*} 非空时有效，从结果集中选取的下标起始值
|
||
* @param count {const int*} 非空时有效，从结果集中的指定下标位置起选取的数量
|
||
* @return {int} 结果集中成员的数量
|
||
* 0: 表示结果集为空或 key 不存在
|
||
* -1: 表示出错或 key 对象非有序集对象
|
||
* >0: 结果集的数量
|
||
* 注：关于区间的选择规则如下：
|
||
* 1）合法的 min 和 max 参数必须包含 ( 或者 [ ， 其中 ( 表示开区间（指定的值
|
||
* 不会被包含在范围之内）， 而 [ 则表示闭区间（指定的值会被包含在范围之内）
|
||
* 2）特殊值 + 和 - 在 min 参数以及 max 参数中具有特殊的意义， 其中 + 表示
|
||
* 正无限， 而 - 表示负无限。因此，向一个所有成员的分值都相同的有序集合发送命令
|
||
* ZRANGEBYLEX <zset> - + ， 命令将返回有序集合中的所有元素
|
||
*/
|
||
int zrangebylex(const char* key, const char* min, const char* max,
|
||
std::vector<string>* out, const int* offset = NULL,
|
||
const int* count = NULL);
|
||
|
||
/**
|
||
* 于一个所有成员的分值都相同的有序集合键 key 来说， 这个命令会返回该集合中，
|
||
* 成员介于 min 和 max 范围内的元素数量
|
||
* @return {int} 符合条件的元素数量
|
||
*/
|
||
int zlexcount(const char* key, const char* min, const char* max);
|
||
|
||
/**
|
||
* 对于一个所有成员的分值都相同的有序集合键 key 来说， 这个命令会移除该集合中，
|
||
* 成员介于 min 和 max 范围内的所有元素
|
||
* @return {int} 被移除的元素数量
|
||
*/
|
||
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);
|
||
|
||
private:
|
||
int zrange_get(const char* cmd, const char* key, int start,
|
||
int stop, std::vector<string>* result);
|
||
int zrange_get_with_scores(const char* cmd, const char* key, int start,
|
||
int stop, std::vector<std::pair<string, double> >& out);
|
||
int zrangebyscore_get(const char* cmd, const char* key,
|
||
const char* min, const char* max, std::vector<string>* out,
|
||
const int* offset = NULL, const int* count = NULL);
|
||
int zrangebyscore_get_with_scores(const char* cmd,
|
||
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 zstore(const char* cmd, const char* dst,
|
||
const std::map<string, double>& keys, const char* aggregate);
|
||
int zstore(const char* cmd, const char* dst, const std::vector<string>& keys,
|
||
const std::vector<double>* weights, const char* aggregate);
|
||
int zpop(const char* cmd, const char* key,
|
||
std::vector<std::pair<string, double> >& out, size_t count);
|
||
int get_with_scores(std::vector<std::pair<string, double> >& out);
|
||
int bzpop(const char* cmd, const char* key, size_t timeout,
|
||
string& member, double* score);
|
||
int bzpop(const char* cmd, const std::vector<string>& keys,
|
||
size_t timeout, string& member, double* score);
|
||
int bzpop_result(string& member, double* score);
|
||
};
|
||
|
||
} // namespace acl
|
||
|
||
#endif // !defined(ACL_CLIENT_ONLY) && !defined(ACL_REDIS_DISABLE)
|