Redis之有序集合（SortedSets）

川长思鸟来 2022-06-05 01:10 444阅读 0赞

有序集合是一个数据类型，这是一种类似于集和哈希的混合。像集合一样，排序集由唯一的、不重复的字符串元素组成，因此在某种意义上，排序集也是一组集合。

虽然set中的元素没有被排序，但排序集中的每个元素都与一个浮点值相关联，这个值称为得分（这也是为什么该类型与哈希类似，因为每个元素都映射到一个值）。

Sorted sets,类似Sets,但是每个字符串元素都关联到一个叫score浮动数值（floating number value）。里面的元素总是通过score进行着排序，所以不同的是，它是可以检索的一系列元素。（例如你可能会问：给我前面10个或者后面10个元素）。

1、添加

/// <summary>
            /// 添加setId/value，默认分数是从1.多*10的9次方以此递增的,自带自增效果
            /// 将所有指定成员添加到键为key有序集合（sorted set）里面。 添加时可以指定多个分数/成员（score/member）对。 
            /// 如果指定添加的成员已经是有序集合里面的成员，则会更新改成员的分数（scrore）并更新到正确的排序位置。
            /// 原指令：ZADD key [NX|XX] [CH] [INCR] score member [score member ...]
            /// 时间复杂度：O(log(N)) 
            /// 参考：http://www.redis.cn/commands/zadd.html
            /// </summary>
            public bool AddItemToSortedSet(string setId, string value)
            {
                return Redis.AddItemToSortedSet(setId, value);
            }
            /// <summary>
            /// 添加setId/value,并设置value的分数
            /// </summary>
            public bool AddItemToSortedSet(string setId, string value, double score)
            {
                return Redis.AddItemToSortedSet(setId, value, score);
            }
            /// <summary>
            /// 为setId添加values集合，values集合中每个value的分数设置为score
            /// </summary>
            public bool AddRangeToSortedSet(string setId, List<string> values, double score)
            {
                return Redis.AddRangeToSortedSet(setId, values, score);
            }
            /// <summary>
            /// 为setId添加values集合，values集合中每个value的分数设置为score
            /// </summary>
            public bool AddRangeToSortedSet(string setId, List<string> values, long score)
            {
                return Redis.AddRangeToSortedSet(setId, values, score);
            }
    
            /// <summary>
            /// 以setId集合为value的数据，分数加scoreby，返回相加后的分数
            /// 原指令：ZINCRBY key increment member
            /// 时间复杂度：O(log(N)) 
            /// 参考：http://www.redis.cn/commands/zincrby.html
            /// </summary>
            public double IncrementItemInSortedSet(string setId, string value, double scoreBy)
            {
                return Redis.IncrementItemInSortedSet(setId, value, scoreBy);
            }

2、获取

/// <summary>
            /// 获取key的所有集合
            /// 原指令：ZRANK key member
            /// 时间复杂度：O(log(N)) 
            /// 参考：http://www.redis.cn/commands/zrank.html
            /// </summary>
            public List<string> GetAllItemsFromSortedSet(string setId)
            {
                return Redis.GetAllItemsFromSortedSet(setId);
            }
            /// <summary>
            /// 获取key的所有集合，倒序输出
            /// </summary>
            public List<string> GetAllItemsFromSortedSetDesc(string setId)
            {
                return Redis.GetAllItemsFromSortedSetDesc(setId);
            }
    
            /// <summary>
            /// 获取所有的集合，带分数
            /// </summary>
            public IDictionary<string, double> GetAllWithScoresFromSortedSet(string setId)
            {
                return Redis.GetAllWithScoresFromSortedSet(setId);
            }
            /// <summary>
            /// 获取key为value的下标值
            /// </summary>
            public long GetItemIndexInSortedSet(string setId, string value)
            {
                return Redis.GetItemIndexInSortedSet(setId, value);
            }
            /// <summary>
            /// 倒序排列获取key为value的下标值
            /// </summary>
            public long GetItemIndexInSortedSetDesc(string setId, string value)
            {
                return Redis.GetItemIndexInSortedSetDesc(setId, value);
            }
    
            /// <summary>
            /// 获取key为value的分数
            /// 原指令：ZSCORE key member
            /// 时间复杂度：O(1) 
            /// 参考：http://www.redis.cn/commands/zscore.html
            /// </summary>
            public double GetItemScoreInSortedSet(string setId, string value)
            {
                return Redis.GetItemScoreInSortedSet(setId, value);
            }
    
            /// <summary>
            /// 获取key集合从低分到高分排序数据，分数从fromscore到分数为toscore的数据
            /// 元素被认为是从低分到高分排序的。
            /// 原指令：ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT offset count]
            /// 时间复杂度：O(log(N)+M)
            /// 参考：http://www.redis.cn/commands/zrangebyscore.html
            /// </summary>
            public List<string> GetRangeFromSortedSetByLowestScore(string setId, double fromScore, double toScore)
            {
                return Redis.GetRangeFromSortedSetByLowestScore(setId, fromScore, toScore);
            }
    
            /// <summary>
            /// 获取key集合从高分到低分排序数据，分数从fromscore到分数为toscore的数据
            /// </summary>
            public List<string> GetRangeFromSortedSetByHighestScore(string setId, double fromScore, double toScore)
            {
                return Redis.GetRangeFromSortedSetByHighestScore(setId, fromScore, toScore);
            }
    
            /// <summary>
            /// 获取key集合从高分到低分排序数据，分数从fromscore到分数为toscore的数据，带分数
            /// </summary>
            public IDictionary<string, double> GetRangeWithScoresFromSortedSetByHighestScore(string setId, double fromScore, double toScore)
            {
                return Redis.GetRangeWithScoresFromSortedSetByHighestScore(setId, fromScore, toScore);
            }
            /// <summary>
            /// 获取key集合从低分到高分排序数据，分数从fromscore到分数为toscore的数据，带分数
            /// </summary>
            public IDictionary<string, double> GetRangeWithScoresFromSortedSetByLowestScore(string setId, double fromScore, double toScore)
            {
                return Redis.GetRangeWithScoresFromSortedSetByLowestScore(setId, fromScore, toScore);
            }
    
    
            /// <summary>
            /// 获取key集合数据，下标从fromRank到分数为toRank的数据
            /// 原指令：ZRANGEBYLEX key min max [LIMIT offset count]
            /// 时间复杂度：O(log(N)+M)
            /// 参考：http://www.redis.cn/commands/zrangebylex.html
            /// </summary>
            public List<string> GetRangeFromSortedSet(string setId, int fromRank, int toRank)
            {
                return Redis.GetRangeFromSortedSet(setId, fromRank, toRank);
            }
            /// <summary>
            /// 获取key集合倒叙排列数据，下标从fromRank到分数为toRank的数据
            /// </summary>
            public List<string> GetRangeFromSortedSetDesc(string setId, int fromRank, int toRank)
            {
                return Redis.GetRangeFromSortedSetDesc(setId, fromRank, toRank);
            }
            /// <summary>
            /// 获取key集合数据，下标从fromRank到分数为toRank的数据，带分数
            /// </summary>
            public IDictionary<string, double> GetRangeWithScoresFromSortedSet(string setId, int fromRank, int toRank)
            {
                return Redis.GetRangeWithScoresFromSortedSet(setId, fromRank, toRank);
            }
            /// <summary>
            ///  获取key集合倒叙排列数据，下标从fromRank到分数为toRank的数据，带分数
            /// </summary>
            public IDictionary<string, double> GetRangeWithScoresFromSortedSetDesc(string setId, int fromRank, int toRank)
            {
                return Redis.GetRangeWithScoresFromSortedSetDesc(setId, fromRank, toRank);
            }

3、总记录数

/// <summary>
            /// 获取key所有集合的数据总数
            /// 原指令：ZCARD key
            /// 时间复杂度：O(1) 
            /// 参考：http://www.redis.cn/commands/zcard.html
            /// </summary>
            public long GetSortedSetCount(string setId)
            {
                return Redis.GetSortedSetCount(setId);
            }
    
            /// <summary>
            /// key集合数据从分数为fromscore到分数为toscore的数据总数
            /// </summary>
            public long GetSortedSetCount(string setId, double fromScore, double toScore)
            {
                return Redis.GetSortedSetCount(setId, fromScore, toScore);
            }
    
            public long GetSortedSetCount(string setId, long fromScore, long toScore)
            {
                return Redis.GetSortedSetCount(setId, fromScore, toScore);
            }
    
            /// <summary>
            /// 用于计算有序集合中指定成员之间的成员数量。
            /// 原指令：ZLEXCOUNT key min max
            /// 时间复杂度：O(log(N))
            /// 参考：http://www.redis.cn/commands/zlexcount.html
            /// </summary>
            /// <param name="key"></param>
            /// <param name="fromScore"></param>
            /// <param name="toScore"></param>
            /// <returns></returns>
            public long GetSortedSetCount(string setId, string fromScore, string toScore)
            {
                return Redis.GetSortedSetCount(setId, fromScore, toScore);
            }

4、删除

/// <summary>
            /// 删除key为value的数据
            /// 原指令：ZREM key member [member ...]
            /// 时间复杂度：O(M*log(N)) 
            /// 参考：http://www.redis.cn/commands/zrem.html
            /// </summary>
            public bool RemoveItemFromSortedSet(string setId, string value)
            {
                return Redis.RemoveItemFromSortedSet(setId, value);
            }
    
            /// <summary>
            /// 删除下标从minRank到maxRank的key集合数据
            /// 原指令：ZREMRANGEBYRANK key start stop
            /// 时间复杂度：O(M*log(N)) 
            /// 参考：http://www.redis.cn/commands/zremrangebyrank.html
            /// </summary>
            public long RemoveRangeFromSortedSet(string setId, int minRank, int maxRank)
            {
                return Redis.RemoveRangeFromSortedSet(setId, minRank, maxRank);
            }
    
            /// <summary>
            /// 删除分数从fromscore到toscore的key集合数据
            /// 原指令：ZREMRANGEBYSCORE key min max
            /// 时间复杂度：O(M*log(N)) 
            /// 参考：http://www.redis.cn/commands/zremrangebyscore.html
            /// </summary>
            public long RemoveRangeFromSortedSetByScore(string setId, double fromscore, double toscore)
            {
                return Redis.RemoveRangeFromSortedSetByScore(setId, fromscore, toscore);
            }
            /// <summary>
            /// 删除key集合中分数最大的数据 
            /// </summary>
            public string PopItemWithHighestScoreFromSortedSet(string setId)
            {
                return Redis.PopItemWithHighestScoreFromSortedSet(setId);
            }
            /// <summary>
            /// 删除key集合中分数最小的数据
            /// </summary>
            public string PopItemWithLowestScoreFromSortedSet(string setId)
            {
                return Redis.PopItemWithLowestScoreFromSortedSet(setId);
            }

5、获取交集 并集

/// <summary>
            /// 获取keys多个集合的交集，并把交集添加的newkey集合中，返回交集数据的总数
            /// 计算给定的numkeys个有序集合的交集，并且把结果放到destination中。 在给定要计算的key和其它参数之前，必须先给定key个数(numberkeys)。
            /// 默认情况下，结果中一个元素的分数是有序集合中该元素分数之和，前提是该元素在这些有序集合中都存在。
            /// 因为交集要求其成员必须是给定的每个有序集合中的成员，结果集中的每个元素的分数和输入的有序集合个数相等。
            /// 原指令：ZINTERSTORE destination numkeys key [key ...] [WEIGHTS weight] [SUM|MIN|MAX]
            /// 时间复杂度：O(N*K)+O(M*log(M))
            /// 参考：http://www.redis.cn/commands/zinterstore.html
            /// </summary>
            public long StoreIntersectFromSortedSets(string newSetId, string[] keys)
            {
                return Redis.StoreIntersectFromSortedSets(newSetId, keys);
            }
    
    
            /// <summary>
            /// 获取keys多个集合的并集，并把并集数据添加到newkey集合中，返回并集数据的总数
            /// 原指令：ZUNIONSTORE destination numkeys key [key ...] [WEIGHTS weight] [SUM|MIN|MAX]
            /// 时间复杂度：O(N*K)+O(M*log(M))
            /// 参考：http://www.redis.cn/commands/zunionstore.html
            /// </summary>
            public long StoreUnionFromSortedSets(string newSetId, string[] keys)
            {
                return Redis.StoreUnionFromSortedSets(newSetId, keys);
            }

6、其它

/// <summary>
            /// 判断key集合中是否存在value数据
            /// </summary>
            public bool SortedSetContainsItem(string setId, string value)
            {
                return Redis.SortedSetContainsItem(setId, value);
            }