import redis
import os
curPath = os.path.abspath(os.path.dirname(__file__))
rootPath = os.path.split(curPath)[0]
import sys
sys.path.append(rootPath)
from common.confop import confOP

class redisClass:
    def connect(self):
        redis_host = confOP.getConfValue(curPath + "/conf.ini", "redis", "redis_host")
        pool = redis.ConnectionPool(host=redis_host)
        r = redis.Redis(connection_pool=pool)
        return r

    def randomkey(self):
        """
        获取随机的一个键
        :return: b'name'
        """
        r = redisClass().connect()
        return r.randomkey()

    def exists(self, name):
        """
        判断一个键是否存在
        :param name:键名
        :return: True
        例子： .exists('name')
        是否存在name这个键
        """
        r = redisClass().connect()
        return r.exists(name)

    def delete(self, name):
        """
        删除一个键
        :param name:键名
        :return: 1
        例子： .delete('name')
        删除name这个键
        """
        r = redisClass().connect()
        return r.delete(name)

    def type(self, name):
        """
        判断键类型
        :param name:
        :return:b'string'
        例子：.type('name')
        判断name这个键类型
        """
        r = redisClass().connect()
        return r.type(name)

    def keys(self, pattern):
        """
        获取所有符合规则的键
        :param pattern:匹配规则
        :return:[b'name']
        例子：.keys('n*')
        获取所有以n开头的键
        """
        r = redisClass().connect()
        return r.keys(pattern)

    def rename(self, src, dst):
        """
        重命名键
        :param src: 原键名；
        :param dst: 新键名
        :return:True
        例子：.rename('name', 'nickname')
        将name重命名为nickname
        """
        r = redisClass().connect()
        return r.rename(src, dst)

    def dbsize(self):
        """
        获取当前数据库中键的数目
        :return: 100
        """
        r = redisClass().connect()
        return r.dbsize()

    def expire(self, name, time):
        """
        设定键的过期时间，单位为秒
        :param name:键名；
        :param time:秒数
        :return:True
        例子：.expire('name', 2)
        将name键的过期时间设置为2秒
        """
        r = redisClass().connect()
        return r.expire(name, time)

    def ttl(self, name):
        """
        获取键的过期时间，单位为秒，-1表示永久不过期
        :param name: 键名
        :return: -1
        例子：.ttl('name')
        获取name这个键的过期时间
        """
        r = redisClass().connect()
        return r.ttl(name)

    def move(self, name, db):
        """
        将键移动到其他数据库
        :param name: 键名；
        :param db: 数据库代号
        :return: True
        例子： .move('name', 2)
        将name移动到2号数据库
        """
        r = redisClass().connect()
        return r.move(name, db)

    def flushdb(self):
        """
        删除当前选择数据库中的所有键
        :return: True
        """
        r = redisClass().connect()
        return r.flushdb()

    def flushall(self):
        """
        删除所有数据库中的所有键
        :return: True
        """
        r = redisClass().connect()
        return r.flushall()

    def set(self, name, value):
        """
        给数据库中键为name的string赋予值value
        :param name: 键名；
        :param value:值
        :return: True
        例子: .set('name', 'Bob')
        给name这个键的value赋值为Bob
        """
        r = redisClass().connect()
        return r.set(name, value)

    def get(self, name):
        """
        返回数据库中键为name的string的value
        :param name: 键名
        :return: b'Bob'
        例子: .get('name')
        返回name这个键的value
        """
        r = redisClass().connect()
        return r.get(name)

    def getset(self, name, value):
        """
        给数据库中键为name的string赋予值value并返回上次的value
        :param name: 键名；
        :param value: 新值
        :return: b'Bob'
        例子: .getset('name', 'Mike')
        赋值name为Mike并得到上次的value
        """
        r = redisClass().connect()
        return r.getset(name, value)

    def mget(self, keys, *args):
        """
        返回多个键对应的value
        :param keys: 键的列表
        :param args:
        :return: [b'Mike', b'Miker']
        例子: .mget(['name', 'nickname'])
        返回name和nickname的value
        """
        r = redisClass().connect()
        return r.mget(keys, *args)

    def setnx(self, name, value):
        """
        如果不存在这个键值对，则更新value，否则不变
        :param name: 键名
        :param value:
        :return: 第一次运行结果是True，第二次运行结果是False
        例子: .setnx('newname', 'James')
        如果newname这个键不存在，则设置值为James
        """
        r = redisClass().connect()
        return r.setnx(name, value)

    def setex(self, name, time, value):
        """
        设置可以对应的值为string类型的value，并指定此键值对应的有效期
        :param name: 键名；
        :param time: 有效期；
        :param value: 值
        :return: True
        例子: .setex('name', 1, 'James')
        将name这个键的值设为James，有效期为1秒
        """
        r = redisClass().connect()
        return r.setex(name, time, value)

    def setrange(self, name, offset, value):
        """
        设置指定键的value值的子字符串
        :param name: 键名；
        :param offset: 偏移量；
        :param value: 值
        :return:xx，修改后的字符串长度
        例子:
        .set('name', 'Hello')
        .setrange('name', 6, 'World')
        设置name为Hello字符串，并在index为6的位置补World
        """
        r = redisClass().connect()
        return r.setrange(name, offset, value)

    def mset(self, mapping):
        """
        批量赋值
        :param mapping: 字典
        :return: True
        例子: .mset({'name1': 'Durant', 'name2': 'James'})
        将name1设为Durant，name2设为James
        """
        r = redisClass().connect()
        return r.mset(mapping)

    def msetnx(self, mapping):
        """
        键均不存在时才批量赋值
        :param mapping: 字典
        :return: True
        例子: .msetnx({'name3': 'Smith', 'name4': 'Curry'})
        在name3和name4均不存在的情况下才设置二者值
        """
        r = redisClass().connect()
        return r.msetnx(mapping)

    def incr(self, name, amount=1):
        """
        键为name的value增值操作，默认为1，键不存在则被创建并设为amount
        :param name: 键名；
        :param amount: 增长的值
        :return: 1，即修改后的值
        例子： .incr('age', 1)
        age对应的值增1，若不存在，则会创建并设置为1
        """
        r = redisClass().connect()
        return r.incr(name, amount)

    def decr(self, name, amount=1):
        """
        键为name的value减值操作，默认为1，键不存在则被创建并将value设置为-amount
        :param name: 键名；
        :param amount: 减少的值
        :return: -1，即修改后的值
        例子： .decr('age', 1)
        age对应的值减1，若不存在，则会创建并设置为-1
        """
        r = redisClass().connect()
        return r.decr(name, amount)

    def append(self, key, value):
        """
        键为name的string的值附加value
        :param key: 键名
        :param value:
        :return: 13，即修改后的字符串长度
        例子： .append('nickname', 'OK')
        向键为nickname的值后追加OK
        """
        r = redisClass().connect()
        return r.append(key, value)

    def substr(self, name, start, end=-1):
        """
        返回键为name的string的子串
        :param name: 键名；
        :param start: 起始索引；
        :param end: 终止索引，默认为-1，表示截取到末尾
        :return: b'ello'
        例子：.substr('name', 1, 4)
        返回键为name的值的字符串，截取索引为1~4的字符
        """
        r = redisClass().connect()
        return r.substr(name, start, end)

    def getrange(self, key, start, end):
        """
        获取键的value值从start到end的子字符串
        :param key: 键名；
        :param start: 起始索引；
        :param end: 终止索引
        :return: b'ello'
        例子： .getrange('name', 1, 4)
        返回键为name的值的字符串，截取索引为1~4的字符
        """
        r = redisClass().connect()
        return r.getrange(key, start, end)

    def rpush(self, name, *values):
        """
        在键为name的列表末尾添加值为value的元素，可以传多个
        :param name: 键名；
        :param values: 值
        :return: 3，列表大小
        例子： .rpush('list', 1, 2, 3)
        向键为list的列表尾添加1、2、3
        """
        r = redisClass().connect()
        return r.rpush(name, *values)

    def lpush(self, name, *values):
        """
        在键为name的列表头添加值为value的元素，可以传多个
        :param name: 键名；
        :param values: 值
        :return: 4，列表大小
        例子：.lpush('list', 0)
        向键为list的列表头部添加0
        """
        r = redisClass().connect()
        return r.lpush(name, *values)

    def llen(self, name):
        """
        返回键为name的列表的长度
        :param name: 键名
        :return: 4
        例子：.llen('list')
        返回键为list的列表的长度
        """
        r = redisClass().connect()
        return r.llen(name)

    def lrange(self, name, start, end):
        """
        返回键为name的列表中start至end之间的元素
        :param name: 键名；
        :param start: 起始索引；
        :param end: 终止索引
        :return: [b'3', b'2', b'1']
        例子：.lrange('list', 1, 3)
        返回起始索引为1终止索引为3的索引范围对应的列表
        """
        r = redisClass().connect()
        return r.lrange(name, start, end)

    def ltrim(self, name, start, end):
        """
        截取键为name的列表，保留索引为start到end的内容
        :param name: 键名；
        :param start: 起始索引；
        :param end: 终止索引
        :return: True
        例子：ltrim('list', 1, 3)
        保留键为list的索引为1到3的元素
        """
        r = redisClass().connect()
        return r.ltrim(name, start, end)

    def lindex(self, name, index):
        """
        返回键为name的列表中index位置的元素
        :param name: 键名；
        :param index: 索引
        :return: b’2’
        例子：.lindex('list', 1)
        返回键为list的列表索引为1的元素
        """
        r = redisClass().connect()
        return r.lindex(name, index)

    def lset(self, name, index, value):
        """
        给键为name的列表中index位置的元素赋值，越界则报错
        :param name: 键名；
        :param index: 索引位置；
        :param value: 值
        :return: True
        例子：.lset('list', 1, 5)
        将键为list的列表中索引为1的位置赋值为5
        """
        r = redisClass().connect()
        return r.lset(name, index, value)

    def lrem(self, name, count, value):
        """
        删除count个键的列表中值为value的元素
        :param name: 键名；
        :param count: 删除个数；
        :param value: 值
        :return: 1，即删除的个数
        例子：.lrem('list', 2, 3)
        将键为list的列表删除两个3
        """
        r = redisClass().connect()
        return r.lrem(name, count, value)

    def lpop(self, name):
        """
        返回并删除键为name的列表中的首元素
        :param name: 键名
        :return: b'5'
        例子：.lpop('list')
        返回并删除名为list的列表中的第一个元素
        """
        r = redisClass().connect()
        return r.lpop(name)

    def rpop(self, name):
        """
        返回并删除键为name的列表中的尾元素
        :param name: 键名
        :return: b'2'
        例子：.rpop('list')
        返回并删除名为list的列表中的最后一个元素
        """
        r = redisClass().connect()
        return r.rpop(name)

    def blpop(self, keys, timeout=0):
        """
        返回并删除名称在keys中的list中的首个元素，如果列表为空，则会一直阻塞等待
        :param keys: 键列表；
        :param timeout: 超时等待时间，0为一直等待
        :return: [b'5']
        例子：.blpop('list')
        返回并删除键为list的列表中的第一个元素
        """
        r = redisClass().connect()
        return r.blpop(keys, timeout)

    def brpop(self, keys, timeout=0):
        """
        返回并删除键为name的列表中的尾元素，如果list为空，则会一直阻塞等待
        :param keys: 键列表；
        :param timeout: 超时等待时间，0为一直等待
        :return: [b'2']
        例子：.brpop('list')
        返回并删除名为list的列表中的最后一个元素
        """
        r = redisClass().connect()
        return r.brpop(keys, timeout)

    def rpoplpush(self, src, dst):
        """
        返回并删除名称为src的列表的尾元素，并将该元素添加到名称为dst的列表头部
        :param src: 源列表的键；
        :param dst: 目标列表的key
        :return: b'2'
        例子：.rpoplpush('list', 'list2')
        将键为list的列表尾元素删除并将其添加到键为list2的列表头部，然后返回
        """
        r = redisClass().connect()
        return r.rpoplpush(src, dst)

    def sadd(self, name, *values):
        """
        向键为name的集合中添加元素
        :param name: 键名；
        :param values: 值，可为多个
        :return: 3，即插入的数据个数
        例子： .sadd('tags', 'Book', 'Tea', 'Coffee')
        向键为tags的集合中添加Book、Tea和Coffee这3个内容
        """
        r = redisClass().connect()
        return r.sadd(name, *values)

    def srem(self, name, *values):
        """
        从键为name的集合中删除元素
        :param name: 键名；
        :param values: 值，可为多个
        :return: 1，即删除的数据个数
        例子： .srem('tags', 'Book')
        从键为tags的集合中删除Book
        """
        r = redisClass().connect()
        return r.srem(name, *values)

    def spop(self, name):
        """
        随机返回并删除键为name的集合中的一个元素
        :param name: 键名
        :return:b'Tea'
        例子：.spop('tags')
        从键为tags的集合中随机删除并返回该元素
        """
        r = redisClass().connect()
        return r.spop(name)

    def smove(self, src, dst, value):
        """
        从src对应的集合中移除元素并将其添加到dst对应的集合中
        :param src: 源集合；
        :param dst: 目标集合；
        :param value: 元素值
        :return: True
        例子：.smove('tags', 'tags2', 'Coffee')
        从键为tags的集合中删除元素Coffee并将其添加到键为tags2的集合
        """
        r = redisClass().connect()
        return r.smove(src, dst, value)

    def scard(self, name):
        """
        返回键为name的集合的元素个数
        :param name:
        :return: 3
        例子：.scard('tags')
        获取键为tags的集合中的元素个数
        """
        r = redisClass().connect()
        return r.scard(name)

    def sismember(self, name, value):
        """
        测试member是否是键为name的集合的元素
        :param name: 键值
        :param value:
        :return: True
        例子：.sismember('tags', 'Book')
        判断Book是否是键为tags的集合元素
        """
        r = redisClass().connect()
        return r.sismember(name, value)

    def sinter(self, keys, *args):
        """
        返回所有给定键的集合的交集
        :param keys: 键列表
        :param args:
        :return: {b'Coffee'}
        例子：.sinter(['tags', 'tags2'])
        返回键为tags的集合和键为tags2的集合的交集
        """
        r = redisClass().connect()
        return r.sinter(keys, *args)

    def sinterstore(self, dest, keys, *args):
        """
        求交集并将交集保存到dest的集合
        :param dest: 结果集合；
        :param keys: 键列表
        :param args:
        :return: 1
        例子：.sinterstore('inttag', ['tags', 'tags2'])
        求键为tags的集合和键为tags2的集合的交集并将其保存为inttag
        """
        r = redisClass().connect()
        return r.sinterstore(dest, keys, *args)

    def sunion(self, keys, *args):
        """
        返回所有给定键的集合的并集
        :param keys: 键列表
        :param args:
        :return: {b'Coffee', b'Book', b'Pen'}
        例子：.sunion(['tags', 'tags2'])
        返回键为tags的集合和键为tags2的集合的并集
        """
        r = redisClass().connect()
        return r.sunion(keys, *args)

    def sunionstore(self, dest, keys, *args):
        """
        求并集并将并集保存到dest的集合
        :param dest: 结果集合；
        :param keys: 键列表
        :param args:
        :return: 3
        例子：.sunionstore('inttag', ['tags', 'tags2'])
        求键为tags的集合和键为tags2的集合的并集并将其保存为inttag
        """
        r = redisClass().connect()
        return r.sunionstore(dest, keys, *args)

    def sdiff(self, keys, *args):
        """
        返回所有给定键的集合的差集
        :param keys: 键列表
        :param args:
        :return: {b'Book', b'Pen'}
        例子：.sdiff(['tags', 'tags2'])
        返回键为tags的集合和键为tags2的集合的差集
        """
        r = redisClass().connect()
        return r.sdiff(keys, *args)

    def sdiffstore(self, dest, keys, *args):
        """
        求差集并将差集保存到dest集合
        :param dest: 结果集合；
        :param keys: 键列表
        :param args:
        :return: 3
        例子：.sdiffstore('inttag', ['tags', 'tags2'])
        求键为tags的集合和键为tags2的集合的差集并将其保存为inttag
        """
        r = redisClass().connect()
        return r.sdiffstore(dest, keys, *args)

    def smembers(self, name):
        """
        返回键为name的集合的所有元素
        :param name: 键名
        :return: {b'Pen', b'Book', b'Coffee'}
        例子：.smembers('tags')
        返回键为tags的集合的所有元素
        """
        r = redisClass().connect()
        return r.smembers(name)

    def srandmember(self, name):
        """
        随机返回键为name的集合中的一个元素，但不删除元素
        :param name: 键值
        :return:
        例子：.srandmember('tags')
        随机返回键为tags的集合中的一个元素
        """
        r = redisClass().connect()
        return r.srandmember(name)

    def zadd(self, name, *args, **kwargs):
        """
        向键为name的zset中添加元素member，score用于排序。如果该元素存在，则更新其顺序
        :param name: 键名；
        :param args: 可变参数
        :param kwargs:
        :return: 2，即添加的元素个数
        例子：.zadd('grade', 100, 'Bob', 98, 'Mike')
        向键为grade的zset中添加Bob（其score为100），并添加Mike（其score为98）
        """
        r = redisClass().connect()
        return r.zadd(name, *args, **kwargs)

    def zrem(self, name, *values):
        """
        删除键为name的zset中的元素
        :param name: 键名；
        :param values: 元素
        :return: 1，即删除的元素个数
        例子：.zrem('grade', 'Mike')
        从键为grade的zset中删除Mike
        """
        r = redisClass().connect()
        return r.zrem(name, *values)

    def zincrby(self, name, value, amount=1):
        """
        如果在键为name的zset中已经存在元素value，则将该元素的score增加amount；否则向该集合中添加该元素，其score的值为amount
        :param name: key名；
        :param value: 元素；
        :param amount: 增长的score值
        :return: 98.0，即修改后的值
        例子：.zincrby('grade', 'Bob', -2)
        键为grade的zset中Bob的score减2
        """
        r = redisClass().connect()
        return r.zincrby(name, value, amount)

    def zrank(self, name, value):
        """
        返回键为name的zset中元素的排名，按score从小到大排序，即名次
        :param name: 键名；
        :param value: 元素值
        :return: 1
        例子：.zrank('grade', 'Amy')
        得到键为grade的zset中Amy的排名
        """
        r = redisClass().connect()
        return r.zrank(name, value)

    def zrevrank(self, name, value):
        """
        返回键为name的zset中元素的倒数排名（按score从大到小排序），即名次
        :param name: 键名；
        :param value: 元素值
        :return: 2
        例子：.zrevrank('grade', 'Amy')
        得到键为grade的zset中Amy的倒数排名
        """
        r = redisClass().connect()
        return r.zrevrank(name, value)

    def zrevrange(self, name, start, end, withscores=False):
        """
        返回键为name的zset（按score从大到小排序）中index从start到end的所有元素
        :param name: 键值；
        :param start: 开始索引；
        :param end: 结束索引；
        :param withscores: 是否带score
        :return: [b'Bob', b'Mike', b'Amy', b'James']
        例子：.zrevrange('grade', 0, 3)
        返回键为grade的zset中前四名元素
        """
        r = redisClass().connect()
        return r.zrevrange(name, start, end, withscores)

    def zrangebyscore(self, name, min, max, start=None, num=None, withscores=False):
        """
        返回键为name的zset中score在给定区间的元素
        :param name: 键名；
        :param min: 最低score；
        :param max: 最高score；
        :param start: 起始索引；
        :param num: 个数；
        :param withscores: 是否带score
        :return: [b'Bob', b'Mike', b'Amy', b'James']
        例子：.zrangebyscore('grade', 80, 95)
        返回键为grade的zset中score在80和95之间的元素
        """
        r = redisClass().connect()
        return r.zrangebyscore(name, min, max, start, num, withscores)

    def zcount(self, name, min, max):
        """
        返回键为name的zset中score在给定区间的数量
        :param name: 键名；
        :param min: 最低score；
        :param max: 最高score
        :return: 2
        例子：.zcount('grade', 80, 95)
        返回键为grade的zset中score在80到95的元素个数
        """
        r = redisClass().connect()
        return r.zcount(name, min, max)

    def zcard(self, name):
        """
        返回键为name的zset的元素个数
        :param name: 键名
        :return: 3
        例子：.zcard('grade')
        获取键为grade的zset中元素的个数
        """
        r = redisClass().connect()
        return r.zcard(name)

    def zremrangebyrank(self, name, min, max):
        """
        删除键为name的zset中排名在给定区间的元素
        :param name: 键名；
        :param min: 最低位次；
        :param max: 最高位次
        :return: 1，即删除的元素个数
        例子：.zremrangebyrank('grade', 0, 0)
        删除键为grade的zset中排名第一的元素
        """
        r = redisClass().connect()
        return r.zremrangebyrank(name, min, max)

    def zremrangebyscore(self, name, min, max):
        """
        删除键为name的zset中score在给定区间的元素
        :param name: 键名；
        :param min: 最低score；
        :param max: 最高score
        :return: 1，即删除的元素个数
        例子：.zremrangebyscore('grade', 80, 90)
        删除score在80到90之间的元素
        """
        r = redisClass().connect()
        return r.zremrangebyscore(name, min, max)

    def hset(self, name, key, value):
        """
        向键为name的散列表中添加映射
        :param name: 键名；
        :param key: 映射键名；
        :param value: 映射键值
        :return: 1，即添加的映射个数
        例子：.hset('price', 'cake', 5)
        向键为price的散列表中添加映射关系，cake的值为5
        """
        r = redisClass().connect()
        return r.hset(name, key, value)

    def hsetnx(self, name, key, value):
        """
        如果映射键名不存在，则向键为name的散列表中添加映射
        :param name: 键名；
        :param key: 映射键名；
        :param value: 映射键值
        :return: 1，即添加的映射个数
        例子：.hsetnx('price', 'book', 6)
        向键为price的散列表中添加映射关系，book的值为6
        """
        r = redisClass().connect()
        return r.hsetnx(name, key, value)

    def hget(self, name, key):
        """
        返回键为name的散列表中key对应的值
        :param name: 键名；
        :param key: 映射键名；
        :return: 5
        例子：.hget('price', 'cake')
        获取键为price的散列表中键名为cake的值
        """
        r = redisClass().connect()
        return r.hget(name, key)

    def hmget(self, name, keys, *args):
        """
        返回键为name的散列表中各个键对应的值
        :param name: 键名；
        :param keys: 映射键名列表
        :param args:
        :return: [b'3', b'7']
        例子：.hmget('price', ['apple', 'orange'])
        获取键为price的散列表中apple和orange的值
        """
        r = redisClass().connect()
        return r.hmget(name, keys, *args)

    def hmset(self, name, mapping):
        """
        向键为name的散列表中批量添加映射
        :param name: 键名；
        :param mapping: 映射字典
        :return: True
        例子：.hmset('price', {'banana': 2, 'pear': 6})
        向键为price的散列表中批量添加映射
        """
        r = redisClass().connect()
        return r.hmset(name, mapping)

    def hincrby(self, name, key, amount=1):
        """
        将键为name的散列表中映射的值增加amount
        :param name: 键名；
        :param key: 映射键名；
        :param amount: 增长量
        :return: 6，修改后的值
        例子：.hincrby('price', 'apple', 3)
        key为price的散列表中apple的值增加3
        """
        r = redisClass().connect()
        return r.hincrby(name, key, amount)

    def hexists(self, name, key):
        """
        键为name的散列表中是否存在键名为键的映射
        :param name: 键名；
        :param key: 映射键名；
        :return: True
        例子：.hexists('price', 'banana')
        键为price的散列表中banana的值是否存在
        """
        r = redisClass().connect()
        return r.hexists(name, key)

    def hdel(self, name, *keys):
        """
        在键为name的散列表中，删除键名为键的映射
        :param name: 键名；
        :param key: 映射键名；
        :return: True
        例子：.hdel('price', 'banana')
        从键为price的散列表中删除键名为banana的映射
        """
        r = redisClass().connect()
        return r.hdel(name, *keys)

    def hlen(self, name):
        """
        从键为name的散列表中获取映射个数
        :param name:  键名
        :return: 6
        例子：.hlen('price')
        从键为price的散列表中获取映射个数
        """
        r = redisClass().connect()
        return r.hlen(name)

    def hkeys(self, name):
        """
        从键为name的散列表中获取所有映射键名
        :param name: 键名
        :return: [b'cake', b'book', b'banana', b'pear']
        例子：.hkeys('price')
        从键为price的散列表中获取所有映射键名
        """
        r = redisClass().connect()
        return r.hkeys(name)

    def hvals(self, name):
        """
        从键为name的散列表中获取所有映射键值
        :param name:  键名
        :return:[b'5', b'6', b'2', b'6']
        例子：.hvals('price')
        从键为price的散列表中获取所有映射键值
        """
        r = redisClass().connect()
        return r.hvals(name)

    def hgetall(self, name):
        """
        从键为name的散列表中获取所有映射键值对
        :param name: 键名
        :return:{b'cake': b'5', b'book': b'6', b'orange': b'7', b'pear': b'6'}
        例子：.hgetall('price')
        从键为price的散列表中获取所有映射键值对
        """
        r = redisClass().connect()
        return r.hgetall(name)


