main_exam_server/rediscontroll/aggregateredis.go

package rediscontroll

import (
	"main_exam_server/common"

	"github.com/go-redis/redis/v8"
)

/**
*列表(list)类型操作
 */
/*
添加元素
@setName			集合名称
@setVal				要添加的值
*/
func SetAdd(rdb *redis.Client, setName string, setVal ...interface{}) (int64, bool) {
	// rdb := RedisInit()
	val, err := rdb.SAdd(ctx, setName, setVal).Result()
	if err != nil {
		return 0, false
	}
	return val, true
}

/*
*随机取一个元素
@setName			集合名称
*/
func SetPop(rdb *redis.Client, setName string) (string, bool) {
	// rdb := RedisInit()
	val, err := rdb.SPop(ctx, setName).Result()
	if err != nil {
		return "", false
	}
	return val, true
}

/*
删除集合里指定的值
@setName			集合名称
@setVal				要添加的值
*/
func SetRem(rdb *redis.Client, setName string, setVal ...interface{}) bool {
	// rdb := RedisInit()
	_, err := rdb.SRem(ctx, setName, setVal).Result()
	if err != nil {
		return false
	}
	return true
}

/*
获取集合所有成员
@setName			集合名称
call back
集合成员,是否获取成功
*/
func GetSetMembers(rdb *redis.Client, setName string) (map[int]interface{}, bool) {
	valMap := common.MapOutint()
	// rdb := RedisInit()
	listMap, err := rdb.SMembers(ctx, setName).Result()
	if err != nil {
		return valMap, false
	}
	for index, val := range listMap {
		valMap[index] = val
	}
	return valMap, true
}

/*
判断元素是否在集合中
@setName			集合名称
call back
*/
func SetIsMember(rdb *redis.Client, setName string, setVal interface{}) bool {
	// rdb := RedisInit()
	exists, err := rdb.SIsMember(ctx, setName, setVal).Result()
	if err != nil {
		return false
	}
	if exists {
		return true
	}
	return false
}

/*
获取集合元素个数
@setName			集合名称
*/
func GetSetCard(rdb *redis.Client, setName string) int64 {
	// rdb := RedisInit()
	total, err := rdb.SCard(ctx, setName).Result()
	if err != nil {
		return 0
	}
	return total
}

/*
-1差集,0,并集,1交集
@setName			集合名称
*/
func SetDiffOrUnionOrInter(rdb *redis.Client, setType int8, firstSetName string, setName string) (map[int]interface{}, bool, int) {
	sendValMap := common.MapOutint()

	isTrue := false
	// rdb := RedisInit()
	switch setType {
	case -1:
		//并集
		Diff, err := rdb.SDiff(ctx, firstSetName, setName).Result()
		if err != nil {
			isTrue = false
		}
		isTrue = true
		for index, val := range Diff {
			sendValMap[index] = val
		}
		return sendValMap, isTrue, 1
	case 1:
		inter, err := rdb.SInter(ctx, firstSetName, setName).Result()
		if err != nil {
			isTrue = false
		}
		isTrue = true
		for index, val := range inter {
			sendValMap[index] = val
		}
		// fmt.Printf("===>%v\n", inter)
		return sendValMap, isTrue, 2
	default:
		//并集
		unionAry, err := rdb.SUnion(ctx, firstSetName, setName).Result()
		if err != nil {
			isTrue = false
		}
		isTrue = true
		for index, val := range unionAry {
			sendValMap[index] = val
		}
		return sendValMap, isTrue, 3
	}

}

/*
有序集合(zset)类型
*/
/*
有序集合添加元素
@sortedName			集合名称
@sortedVal			Score：集合权重，Member：值
*/
func SortedAdd(rdb *redis.Client, sortedName string, sortedVal map[float64]interface{}) {
	// rdb := RedisInit()

	for index, val := range sortedVal {
		rdb.ZAdd(ctx, sortedName, &redis.Z{
			Score:  float64(index),
			Member: val,
		})
	}

}

/*
增加元素分值
@sortedName			集合名称
@sortedScore		集合权重
@sortedMember		成员
*/
func SortedIncrBy(rdb *redis.Client, sortedName string, sortedScore float64, sortedMember string) bool {
	// rdb := RedisInit()
	_, err := rdb.ZIncrBy(ctx, sortedName, sortedScore, sortedMember).Result()
	if err != nil {
		return false
	}
	return true
}

/*
返回有序集中，指定区间内的成员
@sortedName			集合名称
@startIndex			集合开始下标
@stopIndex			集合结束下标
*/
func SortedRange(rdb *redis.Client, sortedName string, startIndex, stopIndex int64) bool {
	// rdb := RedisInit()
	err := rdb.ZRange(ctx, sortedName, startIndex, stopIndex).Err()
	if err != nil {
		return false
	}
	return false
}

/*
返回有序集中，指定区间内的成员。其中成员的位置按分数值递减(从大到小)来排列。
@sortedName			集合名称
@startIndex			集合开始下标
@stopIndex			集合结束下标
*/
func SortedRevRange(rdb *redis.Client, sortedName string, startIndex, stopIndex int64) (map[int]interface{}, bool) {
	valMap := common.MapOutint()
	// rdb := RedisInit()
	valList, err := rdb.ZRevRange(ctx, sortedName, startIndex, stopIndex).Result()
	if err != nil {
		return valMap, false
	}

	for index, val := range valList {
		valMap[index] = val
	}
	return valMap, true
}

/*
返回有序集中，指定区间内的成员。其中成员的位置按分数值递减(从大到小)来排列。(带分值)
@sortedName			集合名称
@startIndex			集合开始下标
@stopIndex			集合结束下标
*/
func SortedRangeWithScores(rdb *redis.Client, sortedName string, startIndex, stopIndex int64) (map[int]interface{}, bool) {
	valMap := common.MapOutint()
	// rdb := RedisInit()
	valList, err := rdb.ZRevRangeWithScores(ctx, sortedName, startIndex, stopIndex).Result()
	if err != nil {
		return valMap, false
	}

	for index, val := range valList {
		valMap[index] = val
	}
	return valMap, true
}

/*
返回有序集合中指定分数区间的成员列表。有序集成员按分数值递增(从小到大)次序排列。
@sortedName			集合名称
@sorterMinVal		集合最小下标
@sorterMaxVal		集合最大下标
*/
func SortedRangeByScore(rdb *redis.Client, sortedName string, sorterMinVal, sorterMaxVal string) (map[int]interface{}, bool) {
	valMap := common.MapOutint()
	// rdb := RedisInit()
	valList, err := rdb.ZRangeByScore(ctx, sortedName, &redis.ZRangeBy{
		Min: sorterMinVal,
		Max: sorterMaxVal,
	}).Result()
	if err != nil {
		return valMap, false
	}

	for index, val := range valList {
		valMap[index] = val
	}
	return valMap, true
}

/*
返回有序集中指定分数区间内的所有的成员。有序集成员按分数值递减(从大到小)的次序排列。
@sortedName			集合名称
@sorterMinVal		集合最小下标
@sorterMaxVal		集合最大下标
*/
func SortedRevRangeByScore(rdb *redis.Client, sortedName string, sorterMinVal, sorterMaxVal string) (map[int]interface{}, bool) {
	valMap := common.MapOutint()
	// rdb := RedisInit()
	valList, err := rdb.ZRevRangeByScore(ctx, sortedName, &redis.ZRangeBy{
		Min: sorterMinVal,
		Max: sorterMaxVal,
	}).Result()
	if err != nil {
		return valMap, false
	}

	for index, val := range valList {
		valMap[index] = val
	}
	return valMap, true
}

/*
命令用于计算集合中元素的数量。
@sortedName			集合名称
*/
func SortedCard(rdb *redis.Client, sortedName string) int64 {
	// rdb := RedisInit()
	count, err := rdb.ZCard(ctx, sortedName).Result()
	if err != nil {
		return 0
	}
	return count
}

/*
计算有序集合中指定分数区间的成员数量。
@sortedName			集合名称
@startIndex			集合开始下标
@stopIndex			集合结束下标
*/
func SortedCount(rdb *redis.Client, sortedName, startIndex, stopIndex string) int64 {
	// rdb := RedisInit()
	count, err := rdb.ZCount(ctx, sortedName, startIndex, stopIndex).Result()
	if err != nil {
		return 0
	}
	return count
}

/*
返回有序集中，成员的分数值。 如果成员元素不是有序集 key 的成员，或 key 不存在，返回 nil 。
@sortedName			集合名称
@sortedMember		集合成员
*/
func SortedScore(rdb *redis.Client, sortedName, sortedMember string) float64 {
	// rdb := RedisInit()
	count, err := rdb.ZScore(ctx, sortedName, sortedMember).Result()
	if err != nil {
		return 0
	}
	return count
}

/*
移除有序集中的一个或多个成员，不存在的成员将被忽略。
@sortedName			集合名称
@sortedMember		集合成员
*/
func SortedRem(rdb *redis.Client, sortedName, sortedMember string) int64 {
	// rdb := RedisInit()
	count, err := rdb.ZRem(ctx, sortedName, sortedMember).Result()
	if err != nil {
		return 0
	}
	return count
}

/*
移除有序集中，指定排名(rank)区间内的所有成员
@sortedName			集合名称
@startIndex			集合开始下标
@stopIndex			集合结束下标
*/
func SortedRemRangeByRank(rdb *redis.Client, sortedName string, startIndex, stopIndex int64) int64 {
	// rdb := RedisInit()
	count, err := rdb.ZRemRangeByRank(ctx, sortedName, startIndex, stopIndex).Result()
	if err != nil {
		return 0
	}
	return count
}

/*
移除有序集中，指定分数（score）区间内的所有成员。
@sortedName			集合名称
@startIndex			集合开始下标
@stopIndex			集合结束下标
*/
func SortedRemRangeByScore(rdb *redis.Client, sortedName, startIndex, stopIndex string) int64 {
	// rdb := RedisInit()
	count, err := rdb.ZRemRangeByScore(ctx, sortedName, startIndex, stopIndex).Result()
	if err != nil {
		return 0
	}
	return count
}