码迷,mamicode.com
首页 > 数据库 > 详细

将mysql数据库中的单个库的数据同步到redis数据库中

时间:2019-06-04 13:27:06      阅读:119      评论:0      收藏:0      [点我收藏+]

标签:pipeline   打印   取数据   count   version   清空   members   cores   ==   

实际代码只有一点,其他的为备忘

# -*- coding:utf-8 -*-
import MySQLdb
import redis

class Config:
    def __init__(self):
        self.mysql_host = ‘192.168.44.60‘
        self.mysql_user = ‘root‘
        self.mysql_port = 3306
        self.mysql_password = ‘123456‘
        self.mysql_db = ‘bamboo‘
        self.mysql_charset = ‘utf8‘
        self.mysql_show_tables = "show tables"
        self.mysql_desc_table = "desc %s"
        self.mysql_query_info = "select * from  %s"

        self.redis_host = "192.168.44.60"
        self.redis_port = 6379
        self.redis_passwd = 123456
        self.redis_db = 0

config = Config()

class MySQLHelper:
    myVersion = 0.1

    def __init__(self):
        self.host = config.mysql_host
        self.user = config.mysql_user
        self.password = config.mysql_password
        self.charset = config.mysql_charset
        self.db = config.mysql_db
        try:
            self.conn = MySQLdb.connect(host=self.host, user=self.user, passwd=self.password,db=self.db,charset=self.charset)
            self.cursor = self.conn.cursor()
        except MySQLdb.Error as e:
            print (‘MySql Error : %d %s‘ % (e.args[0], e.args[1]))

    def query(self, sql):
        try:

            cursor = self.cursor
            cursor.execute(sql)
            return cursor
        except MySQLdb.Error as e:
            print(‘MySql Error: %s SQL: %s‘ % (e, sql))

    def queryOnlyRow(self, sql):
        try:
            cursor = self.query(sql)
            result = cursor.fetchall()
            desc = cursor.description

            row = {}
            for i in range(0, len(result)):
                row[desc[i][0]] = result[i]
            return row
        except MySQLdb.Error as e:
            print(‘MySql Error: %s SQL: %s‘ % (e, sql))

    def queryAll(self, sql):
        try:

            cursor = self.query(sql)
            result = cursor.fetchall()

            desc = cursor.description
            rows = []
            for cloumn in result:
                row = {}
                for i in range(0, len(cloumn)):
                    row[desc[i][0]] = cloumn[i]
                rows.append(row)
            return rows

        except MySQLdb.Error as e:
            print(‘MySql Error: %s SQL: %s‘ % (e, sql))

    def queryTableNums(self,sql):
        try:
            cursor = self.query(sql)
            result = cursor.fetchall()
            row = []
            for cloumn in result:
                row.append(cloumn[0])
            return row

        except MySQLdb.Error as e:
            print(‘Mysql Error: %s SQL: %s‘ %(e,sql))

    def insert(self, tableName, pData):
        try:
            newData = {}
            for key in pData:
                newData[key] = "‘" + str(pData[key]) + "‘"
            key = ‘,‘.join(newData.keys())
            value = ‘,‘.join(map(str,newData.values()))
            sql = "insert into " + tableName + "(" + key + ") values(" + value + ")"
            self.query("set names ‘utf8‘")
            self.query(sql)
            self.commit()
        except MySQLdb.Error as e:
            self.conn.rollback()
            print(‘MySql Error: %s %s‘ % (e.args[0], e.args[1]))

    def update(self, tableName, pData, whereData):
        try:
            newData = []
            keys = pData.keys()
            for i in keys:
                item = "%s=%s" % (i, "‘" + pData[i] + "‘")
                newData.append(item)
            items = ‘,‘.join(newData)
            newData2 = []
            keys = whereData.keys()
            for i in keys:
                item = "%s=%s" % (i, "‘" + whereData[i] + "‘")
                newData2.append(item)
            whereItems = " AND ".join(newData2)
            sql = "update " + tableName + " set " + items + " where " + whereItems
            self.query("set names ‘utf8‘")
            self.query(sql)
            self.commit()
        except MySQLdb.Error as e:
            self.conn.rollback()
            print(‘MySql Error: %s %s‘ % (e.args[0], e.args[1]))

    def getLastInsertRowId(self):
        return self.cursor.lastrowid

    def getRowCount(self):
        return self.cursor.rowcount

    def commit(self):
        self.conn.commit()

    def close(self):
        self.cursor.close()
        self.conn.close()

class RedisHelper():

    __redis_instance = None

    def __init__(self):
        self.host = config.redis_host
        self.port = config.redis_port
        self.passwd = config.redis_passwd
        self.db = config.redis_db
        try:
            self.connPoor = redis.ConnectionPool(host=self.host,port=self.port,db=self.db,password=self.passwd)
            self.rd = redis.Redis(connection_pool=self.connPoor)
        except redis.DataError as e:
            print(‘Redis Error : %d %s‘ % (e.args[0], e.args[1]))

    @staticmethod
    def getObj():
        if RedisHelper.__redis_instance:
            return RedisHelper.__redis_instance
        else:
            RedisHelper.__redis_instance = RedisHelper().rd
            return RedisHelper.__redis_instance

    # string 操作

    def setkey(self,key,value,**kwargs):
        """
        set(name, value, ex=None, px=None, nx=False, xx=False)
        :param key: 键
        :param value: 值
        :param kwargs:
            在Redis中设置值,默认,不存在则创建,存在则修改
            参数:
            ex,过期时间(秒)
            px,过期时间(毫秒)
            nx,如果设置为True,则只有name不存在时,当前set操作才执行
            xx,如果设置为True,则只有name存在时,当前set操作才执行
        :return: True or False
        """
        res = self.rd.set(key,value,**kwargs)

        return res

    def getkey(self,key):
        return self.rd.get(key)

    def setnxkey(self,key,value):
        """
        :param key:
        :param value:
        :return: True or False
        设置值,只有key不存在时,执行设置操作(添加)
        """
        return self.rd.setnx(key,value)

    def setexkey(self,key,value,time=5):
        """
        :param key:
        :param value:
        :param time: 过期时间 (秒 或 timedelta对象)
        :return: True or False
        """
        return self.rd.setex(key,time,value)

    def psetexkey(self,key,value,time):
        """
        :param key:
        :param value:
        :param time: time_ms,过期时间(数字毫秒 或 timedelta对象)
        :return:
        """
        return self.rd.psetex(key,time,value)

    def msetkey(self,mapping):
        """
        批量设置多个值
        :param mapping: {‘k1‘:‘v1‘,‘k2‘:‘v2‘} or k1=‘v1‘,k2=‘v2‘
        :return:
        """
        return self.rd.mset(mapping)

    def mgetkey(self,keys,*args):
        """
        批量获取多个值
        ‘k1‘,‘k2‘ or [‘k1‘,‘k2‘]
        :param keys:
        :param args:
        :return:
        """
        return self.rd.mget(keys,args)

    def getsetkey(self,key,value):
        """
        获取值并设置新值
        :param key:
        :param value:
        :return:
        """
        return self.rd.getset(key,value)

    def getrangekey(self,key,start,end):
        """
        获取子序列(根据字节获取,非字符) 一个汉字,是占3个字节
        :param key:
        :param start: bytes 起始位置(包含)
        :param end: bytes  结束位置(包含)
        :return:
        set ‘name‘ ‘helloworld‘
        OK
        GETRANGE ‘name‘ 0 2
        "hel"
        getrange ‘name‘ 0 -1
        "helloworld"
        """
        return self.rd.getrange(key,start,end)

    def setrange(self,key,index,value):
        """
        修改字符串内容,从指定字符串索引开始向后替换(新值太长时,则向后添加)
        参数:

        :param key:
        :param index: 字符串的索引,字节(一个汉字三个字节)
        :param value: 要设置的值
        :return:
        """
        return self.rd.setrange(key,index,value)

    def strlenkey(self,key):
        """
        返回name对应值的字节长度(一个汉字3个字节)
        :param key:
        :return:
        """
        return self.rd.strlen(key)

    def incrkey(self,key):
        """
        自增 name对应的值,当name不存在时,则创建name=amount,否则,则自增。
        :param key:
        :param amount: 自增数 必须是整数 一次只能自增一个
        :return:
        """

        return self.rd.incr(key,1)

    def incrbykey(self,key,amount=1):
        """
        自增 key对应的值,当key不存在时,则创建key=amount,否则,则自增。
        :param key:
        :param amount: 自增数 必须是整数
        :return:
        """
        try:
            if not isinstance(amount,int):
                raise TypeError(‘amount 必须是整数‘)
            return self.rd.incrby(key,amount)
        except Exception as e:
            return "Func incrbykey Error : %d %s" % (e.args[0], e.args[1])

    def incrbyfloatkey(self,key,amount=1.0):
        """
        自增 key对应的值,当key不存在时,则创建key=amount,否则,则自增。
        :param key:
        :param amount: 自增数(浮点型)
        :return:
        """
        try:
            if not isinstance(amount,float):
                raise TypeError(‘amount 必须是浮点数‘)
            return self.rd.incrbyfloat(key,amount)
        except Exception as e:
            return "Func incrbyfloatkey Error : %d %s" % (e.args[0], e.args[1])

    def decrkey(self,key):
        """
        自减 name对应的值,当name不存在时,则创建name=amount,否则,则自减
        :param name:
        :return:
        """
        self.rd.decr(key,1)

    def decrbykey(self,key,amount=1):
        """
        自减 key对应的值,当key不存在时,则创建key=amount,否则,则自减。
        :param key:
        :param amount: 自减数 必须是整数
        :return:
        """
        try:
            if not isinstance(amount, int):
                raise TypeError(‘amount 必须是整数‘)
            return self.rd.decrby(key, amount)
        except Exception as e:
            return "Func decrbykey Error : %d %s" % (e.args[0], e.args[1])

    def appendkey(self,key,value):
        """
        在redis key对应的值后面追加内容
        :param key:
        :param value: 要追加的字符串
        :return:
        """
        return self.rd.append(key,value)

    def setbitkey(self,key,index,value):
        """
        注:如果在Redis中有一个对应: n1 = "foo",
        那么字符串foo的二进制表示为:01100110 01101111 01101111
        所以,如果执行 setbit(‘n1‘, 7, 1),则就会将第7位设置为1,
        那么最终二进制则变成 01100111 01101111 01101111,即:"goo"

        扩展,转换二进制表示:
        source = "陈思维"
        source = "foo"
        for i in source:
        num = ord(i)
        print bin(num).replace(‘b‘,‘‘)
        特别的,如果source是汉字 "陈思维"怎么办?
        答:对于utf-8,每一个汉字占 3 个字节,那么 "陈思维" 则有 9个字节
        对于汉字,for循环时候会按照 字节 迭代,那么在迭代时,将每一个字节转换 十进制数,然后再将十进制数转换成二进制
        11100110 10101101 10100110 11100110 10110010 10011011 11101001 10111101 10010000

        对name对应值的二进制表示的位进行操作
        :param key:
        :param index: 位的索引(将值变换成二进制后再进行索引)
        :param value: 值只能是 1 或 0
        :return:
        """
        try:
            if not isinstance(index,int):
                raise TypeError(‘index 只能是数字‘)
            if  value not in [0,1]:
                raise ValueError(‘value 只能是0或1‘ )

            return self.rd.setbit(key,index,value)

        except Exception as e:
            return "Redis Error : %d %s" % (e.args[0], e.args[1])

    def getbitkey(self,key,index):
        """
        获取name对应的值的二进制表示中的某位的值 (0或1)
        :param key:
        :param index: 0 or 1
        :return:
        """
        try:
            if index not in [0,1]:
                raise ValueError("index 值只能是0或1")
            return self.rd.getbit(key,index)
        except Exception as e:
            return "Redis Error : %d %s" % (e.args[0], e.args[1])

    def bitcountkey(self,key,start=None,end=None):
        """
        获取name对应的值的二进制表示中 1 的个数
        :param key:
        :param start:
        :param end:
        :return:
        """
        return self.rd.bitcount(key,start,end)

    def bitopkey(self,operation,new_key,*keys):
        """
        bitop("AND", ‘new_name‘, ‘n1‘, ‘n2‘, ‘n3‘)
        获取Redis中n1,n2,n3对应的值,然后讲所有的值做位运算(求并集),然后将结果保存 new_name 对应的值中
        r.set("foo","1")  # 0110001
        r.set("foo1","2")  # 0110010
        print(r.mget("foo","foo1"))  # [‘goo1‘, ‘baaanew‘]
        print(r.bitop("AND","new","foo","foo1"))  # "new" 0 0110000
        print(r.mget("foo","foo1","new"))

        source = "12"
        for i in source:
        num = ord(i)
        print(num)  # 打印每个字母字符或者汉字字符对应的ascii码值 f-102-0b100111-01100111
        print(bin(num))  # 打印每个10进制ascii码值转换成二进制的值 0b1100110(0b表示二进制)
        print bin(num).replace(‘b‘,‘‘)  # 将二进制0b1100110替换成01100110

        获取多个值,并将值做位运算,将最后的结果保存至新的name对应的值
        :param operation: AND(并) 、 OR(或) 、 NOT(非) 、 XOR(异或)
        :param new_key: new key
        :param keys: 要查找的Redis的name
        :return:
        """
        return self.rd.bitop(operation,new_key,keys)

    # hash 操作

    def hsetkey(self,name,key,value):
        """
        name对应的hash中设置一个键值对(不存在,则创建;否则,修改)

        :param name: redis的name
        :param key: name对应的hash中的key
        :param value: name对应的hash中的value
        :return:
        """
        return self.rd.hset(name,key,value)

    def hmsetkey(self,name,mapping):
        """
        在name对应的hash中批量设置键值对
        :param name:
        :param mapping: {‘k1‘:‘v1‘,‘k2‘:‘v2‘}
        :return:
        """
        return self.rd.hmset(name,mapping)

    def hgetkey(self,name,key):
        """
        在name对应的hash中获取根据key获取value
        :param name:
        :param key:
        :return:
        """
        return self.rd.hget(name,key)

    def hgetallkey(self,name):
        """
        获取hash中对应name的所有值
        :param name:
        :return:
        """
        return self.rd.hgetall(name)

    def hmgetkey(self,name,keys,*args):
        """
        在name对应的hash中获取多个key的值
        :param name:
        :param keys: [‘k1‘,‘k2‘,‘k3‘]
        :param args: ‘k1‘,‘k2‘,‘k3‘
        :return:
        """
        return self.rd.hmget(name,keys,args)

    def hlenkey(self,name):
        """
        获取name对应的hash中的键值对的个数
        :param name:
        :return:
        """
        return self.rd.hlen(name)

    def hallkeys(self,name):
        """
        获取name对应的hash中所有的key的值
        :param name:
        :return:
        """
        return self.rd.hkeys(name)

    def hvalskeys(self, name):
        """
        获取name对应的hash中所有的value的值
        :param name:
        :return:
        """
        return self.rd.hvals(name)

    def hexistskeys(self,name,key):
        """
        检查name对应的hash是否存在当前传入的key 类似字典的in
        :param name:
        :param key:
        :return:
        """
        return self.rd.hexists(name,key)

    def hdelkeys(self,name,*keys):
        """
        将name值对应的hash中指定key的键值对删除
        :param name:
        :param keys: ‘k1‘ or ‘k1‘,‘k2‘
        :return:
        """
        return self.rd.hdel(name,keys)

    def hincrby(self,name,key,amount=1):
        """
        将key对应的value--整数 自增1或者2,或者别的整数 负数就是自减(自增name对应的hash中的指定key的值,不存在则创建key=amount)
        :param name:
        :param key:
        :param amount:
        :return:
        """
        try:
            if not isinstance(amount,int):
                raise TypeError(‘amount 只能是整数‘)
            return self.rd.hincrby(name,key,amount)
        except Exception as e:
            return "Func hincrby Error : %d %s" % (e.args[0], e.args[1])

    def hincrbyfloatkeys(self,name,key,amount=1.0):
        """
        将key对应的value--浮点数 自增1.0或者2.0,或者别的浮点数 负数就是自减 (自增name对应的hash中的指定key的值,不存在则创建key=amount)
        :param name:
        :param key:
        :param amount: 自增数(浮点数)
        :return:
        """
        try:
            if not isinstance(amount,float):
                raise TypeError(‘amount 只能是浮点数‘)
            return self.rd.hincrbyfloat(name, key, amount)
        except Exception as e:
            return "Func hincrby Error : %d %s" % (e.args[0], e.args[1])

    def hscankeys(self,name,cursor=0,match=None,count=None):
        """
        增量式迭代获取,对于数据大的数据非常有用,hscan可以实现分片的获取数据,并非一次性将数据全部获取完,从而放置内存被撑爆
        :param name:
        :param curosr: 游标(基于游标分批取获取数据)
        :param match: 匹配指定key,默认None 表示所有的key
        :param count: 每次分片最少获取个数,默认None表示采用Redis的默认分片个数
        :return:
        """
        return self.rd.hscan(name,cursor,match,count)

    def hscaniterkeys(self,name,match=None,count=None):
        """
        利用yield 封装hscan创建生成器,实现分批器redis中获取数据
        :param name:
        :param match: 匹配指定key,默认表示所有key
        :param count: 每次分片最少获取个数,默认None表示采用Redis的默认分片个数
        :return:
        """
        return self.rd.hscan_iter(name,match,count)

    # list 操作

    def lpushkeys(self,key,values):
        """
        增加(类似于list的append,只是这里是从左边新增加)--没有就新建
        在name对应的list中添加元素,每个新的元素都添加到列表的最左边
        lpush(‘xx‘,11,12,13)
        :param key:
        :param values:
        :return:
        """
        return self.rd.lpush(key,values)

    def  rpushkeys(self,key,values):
        """
        增加(类似于list的append,只是这里是从右边新增加)--没有就新建
        在name对应的list中添加元素,每个新的元素都添加到列表的最右边
        rpush(‘xx‘,11,12,13)
        :param key:
        :param values:
        :return:
        """
        return self.rd.rpush(key,values)

    def lpushxkeys(self,key,value):
        """
        在key对应的list中添加一个元素,只有key存在时,值添加到列表的最左边,key不存在则不能创建,但是不报错
        :param key:
        :param values:
        :return:
        """
        return self.rd.lpushx(key,value)

    def rpushxkeys(self,key,value):
        """
        在key对应的list中添加一个元素,只有key存在时,值添加到列表的最右边,key不存在则不能创建,但是不报错
        :param key:
        :param value:
        :return:
        """
        return self.rd.rpushx(key,value)

    def linsertkeys(self,key,where,refvalue,value):
        """
        在key对应的列表的某一个值前或后插入一个新值

        r.linsert("list2", "before", "11", "00")   # 往列表中左边第一个出现的元素"11"前插入元素"00"

        :param key:
        :param where: before or after
        :param refvalue: 标杆值,即:在它前后插入数据
        :param value:  要插入的数据
        :return:
        """
        try:
            if str(where).lower() not in [‘before‘,‘after‘]:
                raise ValueError(‘where 值只能是 before 或 after‘)
            return self.rd.linsert(key,where,refvalue,value)
        except Exception as e:
            return "Func linsertkeys Error: %d %s"%(e.args[0],e.args[1])

    def lsetkeys(self,key,index,value):
        """
        对key对应的list中的某一个索引位置重新赋值
        :param key:
        :param index: 索引值,从0 开始
        :param value:
        :return:
        """
        try:
            if not isinstance(index,int):
                raise TypeError(‘index 只能是整数‘)
            return self.rd.lset(key,index,value)
        except Exception as e:
            return "Func lsetkeys: %d %s"%(e.args[0],e.args[1])

    def lremkeys(self,key,num,value):
        """
        在key对应的list中删除指定的值
        :param key:
        :param value:
        :param num: num=0,删除列表中所有指定值,num=2,从前到后,删除2个,num=1,从前到后,删除左边第一个,num=-2,从后到前,删除两个
        :return:
        """
        return self.rd.lrem(key,num,value)

    def lpopkeys(self,key):
        """
        在key 对应的列表的左侧获取第一个元素并在列表中移除,返回值则是第一个元素
        :param key:
        :return:
        """
        return self.rd.lpop(key)

    def rpopkeys(self,key):
        """
        在key 对应的列表的右侧获取第一个元素并在列表中移除,返回值则是第一个元素
        :param key:
        :return:
        """
        return self.rd.rpop(key)

    def ltrimkeys(self,key,start,end):
        """
        在key对应的list中移除没有在start - end 索引之间的值
        :param key:
        :param start: 索引的开始位置
        :param end: 索引的结束位置
        :return:
        """
        return self.rd.ltrim(key,start,end)

    def lindexkeys(self,key,index):
        """
        在name对应的list中根据索引获取列表元素
        :param key:
        :param index:
        :return:
        """
        return self.rd.lindex(key,index)

    def rpoplpushkeys(self,srckey,dstkey):
        """
        将元素从一个表移动到另一个表中(从一个列表取出最右边的元素,同时将其添加至另一个列表的最左边)
        :param srckey:
        :param detkey:
        :return:
        """
        return self.rd.rpoplpush(srckey,dstkey)

    def brpoplpushkeys(self,srckey,dstkey,timeout=0):
        """
        从一个列表的右侧移除一个元素并将其添加到另一个列表的左侧,可以设置超时
        :param srckey:
        :param dstkey:
        :param timeout: 当seckey对应的list中没有数据时,阻塞等待其有数据的超时时间 单位为秒,0表示永远阻塞
        :return:
        """
        return self.rd.brpoplpush(srckey,dstkey,timeout)

    def blpopkeys(self,keys,timeout):
        """
        将多个列表排序,按照从左到右去pop对应的list元素
        :param keys:
        :param timeout: 超时时间,当元素所有列表的元素获取完之后,阻塞等待列表内有数据的时间(秒), 0 表示永远阻塞
        :return:
        """
        return self.rd.blpop(keys,timeout)

    def brpopkeys(self,keys,timeout):
        """
        将多个列表排序,按照从右到左去pop对应的list元素
        :param keys:
        :param timeout: 超时时间,当元素所有列表的元素获取完之后,阻塞等待列表内有数据的时间(秒), 0 表示永远阻塞
        :return:
        """
        return self.rd.brpop(keys,timeout)

    def llenkeys(self,key):
        """
        返回key的数据长度
        :param key:
        :return:
        """
        return self.rd.llen(key)

    def lrangekeys(self,key,start=0,end=-1):
        """
        获取key的全部数据值 通常与llen联用
        :param key:
        :param start: 起始位置(包括)
        :param end: 结束位置(包括)
        :return:
        """
        return self.rd.lrange(key,start,end)

    def listiterkeys(self,key):
        """
        list增量迭代
        :param key:
        :return: 返回yield 生成器
        """
        list_count = self.rd.llen(key)
        for index in range(list_count):
            yield self.rd.lindex(key,index)

    # set 操作

    def saddkeys(self,key,values):
        """
        :key对应的集合中添加元素,重复的元素将忽略
        saddkeys(‘xxx‘,1,2,3,4,5)
        :param key:
        :param values:
        :return:
        """
        return self.rd.sadd(key,values)

    def scardkeys(self,key):
        """
        获取元素个数,类似于len
        :param key:
        :return:
        """
        return self.rd.scard(key)

    def smemnerkeys(self,key):
        """
        获取key对应的集合的所有成员
        :param key:
        :return:
        """
        return self.rd.smembers(key)

    def sscankeys(self, key, cursor=0, match=None, count=None):
        """
        获取集合中所有的成员 -- 元组形式
        :param key:
        :param cursor:
        :param match:
        :param count:
        :return:
        """
        return self.rd.sscan(key,cursor,match,count)

    def sscaniterkeys(self,key,match=0,count=None):
        """
        获取集合中所有的成员 --迭代器方式
        :param key:
        :param match:
        :param count:
        :return:
        """
        return self.rd.sscan_iter(key,match,count)

    def sdiffkeys(self,keys,*args):
        """
        在第一个key对应的集合中且不在其他key对应的集合的元素集合
        sdiffkeys(‘a‘,‘b) 在集合a中并且不再集合b中
        :param keys:
        :param args:
        :return:
        """
        return self.rd.sdiff(keys,args)

    def sdiffstorekeys(self,dstkey,keys,*args):
        """
        获取第一个key对应的集合中且不在其他name对应的结合,在将其加入到dstkey对应的集合中
        :param dstkey:
        :param keys:
        :param args:
        :return:
        """
        res = self.rd.sdiffstore(dstkey,keys,args)
        return res

    def sinterkeys(self,keys,*args):
        """
        获取多个keys对应集合的交集
        :param keys:
        :param args:
        :return:
        """
        return self.rd.sinter(keys,args)

    def sinterstorekeys(self,dstkey,keys,*args):
        """
        获取多个keys对应集合的交集,再将其加入到dstkey对应的集合中
        :param dstkey:
        :param keys:
        :param args:
        :return:
        """
        res = self.rd.sinterstore(dstkey,keys,args)
        return res

    def sunionkeys(self,keys,*args):
        """
        获取多个key对应的集合的并集
        :param keys:
        :param args:
        :return:
        """
        return self.rd.sunion(keys,args)

    def sunionstorekeys(self,dstkey,keys,*args):
        """
        获取多个key对应集合的并集,并将其结果保存到dstkey对应的集合中
        :param dstkey:
        :param keys:
        :param args:
        :return:
        """
        return self.rd.sunionstore(dstkey,keys,args)

    def sismemberkeys(self,key,value):
        """
        检查value是否是key对应的结合的成员,结果返回True or False
        :param key:
        :param value:
        :return: True or False
        """
        return self.rd.sismember(key,value)

    def smovekeys(self,srckey,dstkey,value):
        """
        将某个成员从一个集合中移动到另一个集合
        :param srckey:
        :param dstkey:
        :param value:
        :return:
        """
        return self.rd.smove(srckey,dstkey,value)

    def spopkeys(self,key):
        """
        从集合移除一个成员,并将其返回,说明一下,集合是无序的,所有都是随机删除的
        :param key:
        :return:
        """
        return self.rd.spop(key)

    def sremkeys(self,key,values):
        """
        在key对应的集合中删除某些值
        sremkeys(‘xx‘,‘a‘,‘b‘)
        :param key:
        :param values:
        :return:
        """
        return self.rd.srem(key,values)

    #  有序集合  zset 操作

    def zaddkeys(self,key,mapping):
        """
        在key对应的有序集合中添加元素
        zaddkeys(‘xx‘,{‘k1‘:1,‘k2‘:2})

        :param key:
        :param args:
        :param kwargs:
        :return:
        """
        return self.rd.zadd(key,mapping)

    def zcardkeys(self,key):
        """
        获取有序集合元素的个数
        :param key:
        :return:
        """
        return self.rd.zcard(key)

    def zrangekeys(self,key,start,stop,desc=False,withscores=False,score_cast_func=float):
        """
        获取有序集合索引范围内的元素
        :param key:
        :param start: 索引起始位置
        :param stop: 索引结束位置
        :param desc: 排序规则,默认按照分数从小到大排序
        :param withscores: 是否获取元素的分数,默认之火去元素的值
        :param score_cast_func: 对分数进行数据转换的函数
        :return:
        """
        return self.rd.zrange(key,start,stop,desc,withscores,score_cast_func)

    def zrevrangekeys(self,key,start,end,withscores=False,score_cast_func=float):
        """
        从大到小排序
        :param key:
        :param start:
        :param end:
        :param withscores:
        :param score_cast_func:
        :return:
        """
        return self.rd.zrevrange(key,start,end,withscores,score_cast_func)

    def zrangebyscorekeys(self,key,min,max,start=None,num=None,withscores=False,score_cast_func=float):
        """
        按照分数返回获取key对应的有序集合的元素
        zrangebyscore("zset3", 15, 25)) # # 在分数是15-25之间,取出符合条件的元素
        zrangebyscore("zset3", 12, 22, withscores=True)   # 在分数是12-22之间,取出符合条件的元素(带分数)

        :param key:
        :param min:
        :param max:
        :param start:
        :param num:
        :param withscores:
        :param score_cast_func:
        :return:
        """
        return self.rd.zrangebyscore(key,min,max,start,num,withscores,score_cast_func)

    def zrevrangebyscorekeys(self,key,max,min,start=None,num=None,withscores=False,score_cast_func=float):
        """
        按照分数范围获取有序集合的元素并排序(默认按照从大到小排序)
        :param key:
        :param max:
        :param min:
        :param start:
        :param num:
        :param withscores:
        :param score_cast_func:
        :return:
        """
        return self.rd.zrevrangebyscore(key,max,min,start,num,withscores,score_cast_func)

    def zscankeys(self,key,cursor=0,match=None,count=None,score_cast_func=float):
        """
        获取所有元素 -- 默认按照分数顺序排序
        :param key:
        :param cursor:
        :param match:
        :param count:
        :param score_cast_func:
        :return:
        """
        return self.rd.zscan(key,cursor,match,count,score_cast_func)

    def zscaniterkeys(self,key,match=None,count=None,score_cast_func=float):
        """
        获取所有元素的迭代器
        :param key:
        :param match:
        :param count:
        :param score_cast_func:
        :return:
        """
        return self.rd.zscan_iter(key,match,count,score_cast_func)

    def zcountkeys(self,key,min,max):
        """
        获取key对应的有序集合中分数在[min,max] 之间的个数
        :param key:
        :param min:
        :param max:
        :return:
        """
        return self.rd.zcount(key,min,max)

    def zincrbykey(self,key,value,amount=1):
        """
        自增key对应的有序集合key对应的分数
        :param key:
        :param value:
        :param amount:
        :return:
        """
        return self.rd.zincrby(key,amount,value)

    def zrankeys(self,key,value):
        """
        获取某个值在key对应的有序集合中的索引(从0开始),默认是从小到大顺序
        :param key:
        :param value:
        :return:
        """
        return self.rd.zrank(key,value)

    def zrevrankey(self,key,value):
        """
        获取某个值在key对应的有序集合中的索引,默认是从大到小顺序
        :param key:
        :param value:
        :return:
        """
        return self.rd.zrevrank(key,value)

    def zremkeys(self,key,values):
        """
        删除key对应的有序集合中值是value的成员
        :param key:
        :param value:
        :return:
        """
        return self.rd.zrem(key,values)

    def zremrangebyrankeys(self,key,min,max):
        """
        删除根据排行范围删除,按照索引删除
        :param key:
        :param min:
        :param max:
        :return:
        """
        return self.rd.zremrangebyrank(key,min,max)

    def zremrangebyscoreskeys(self,key,min,max):
        """
        删除根据分数范围删除,按照分数范围删除
        :param key:
        :param min:
        :param max:
        :return:
        """
        return self.rd.zremrangebyscore(key,min,max)

    def zscoreskeys(self,key,value):
        """
        获取key对应有序集合中value对应的分数
        :param key:
        :param value:
        :return:
        """
        return self.rd.zscore(key,value)

    # 其他常用操作

    def deletekeys(self,*keys):
        """
        根据删除redis中的任意数据类型
        deletekeys(‘gender‘,‘cname‘) 可以删除多个key
        :param keys:
        :return:
        """
        return self.rd.delete(*keys)

    def existskeys(self,key):
        """
        检测redis的key 是否存在,存在就返回True,False则不存在
        :param key:
        :return:
        """
        return  self.rd.exists(key)

    def getkeys(self,pattern=""):
        """
        根据模型获取redis的key

        getkeys * 匹配数据库中所有 key 。
        getkeys h?llo 匹配 hello , hallo 和 hxllo 等。
        getkeys hllo 匹配 hllo 和 heeeeello 等。
        getkeys h[ae]llo 匹配 hello 和 hallo ,但不匹配 hillo

        :param pattern:
        :return:
        """
        return self.rd.keys(pattern)

    def expirekeys(self,key,time):
        """
        设置超时时间,为某个key设置超时时间
        :param key:
        :param time: 秒
        :return:
        """
        return self.rd.expire(key,time)

    def renamekeys(self,srckey,dstkey):
        """
        对key进行重命名
        :param srckey:
        :param dstkey:
        :return:
        """
        return self.rd.rename(srckey,dstkey)

    def randomkeys(self):
        """
        随即获取一个key(不删除)
        :return:
        """
        return self.rd.randomkey()

    def getkeytypes(self,key):
        """
        获取key的类型
        :param key:
        :return:
        """
        return self.rd.type(key)

    def scankeys(self,cursor=0,match=None,count=None):
        """
        查看所有key,终极大招
        :param cursor:
        :param match:
        :param count:
        :return:
        """
        return self.rd.scan(cursor,match,count)

    def scaniterkeys(self,match=None,count=None):
        """
        查看所有key的迭代器,防止内存被撑爆
        :param match:
        :param count:
        :return:
        """
        return self.rd.scan_iter(match,count)

    def dbsizekeys(self):
        """
        当前redis包含多少条数据
        :return:
        """
        return self.rd.dbsize()

    def savekeys(self):
        """
        将数据刷入磁盘中,保存时阻塞
        :return:
        """
        return self.rd.save()

    def flushdbkeys(self,asynchronous=False):
        """
        清空当前数据库的所有数据,请谨慎使用
        :param asynchronous:异步
        :return:
        """
        return self.rd.flushdb(asynchronous)

    def flushallkeys(self,asynchronous=False):
        """
        清空redis所有库中的数据,不到最后时刻 请不要使用
        :param asynchronous: 异步
        :return:
        """

        return self.rd.flushall(asynchronous)

    # 创建管道

    """
    redis默认在执行每次请求都会创建(连接池申请连接)和断开(归还连接池)一次连接操作,
    如果想要在一次请求中指定多个命令,则可以使用pipline实现一次请求指定多个命令,
    并且默认情况下一次pipline 是原子性操作。
    管道(pipeline)是redis在提供单个请求中缓冲多条服务器命令的基类的子类。
    它通过减少服务器-客户端之间反复的TCP数据库包,从而大大提高了执行批量命令的功能。

    """
    def createpipe(self):
        """
        pipeline(transaction=False)    # 默认的情况下,管道里执行的命令可以保证执行的原子性,执行pipe = r.pipeline(transaction=False)可以禁用这一特性。
        pipe = r.pipeline() # 创建一个管道

        pipe.set(‘name‘, ‘jack‘)
        pipe.set(‘role‘, ‘sb‘)
        pipe.sadd(‘faz‘, ‘baz‘)
        pipe.incr(‘num‘)    # 如果num不存在则vaule为1,如果存在,则value自增1
        pipe.execute()

        pipe.set(‘hello‘, ‘redis‘).sadd(‘faz‘, ‘baz‘).incr(‘num‘).execute()

        :return:
        """
        return  self.rd.pipeline()

    def disconectkeys(self):
        return self.connPoor.disconnect()

class QueryAllData():
    def __init__(self):
        self.show_tables = config.mysql_show_tables
        self.desc_table = config.mysql_desc_table
        self.query_info = config.mysql_query_info

    def query_tables_info(self):
        mhelper = MySQLHelper()
        tables_list = mhelper.queryTableNums(self.show_tables)
        tables_attr = {}
        for table in tables_list:
            rows = mhelper.queryAll(self.query_info %table)
            tables_attr[table] = rows

        mhelper.close()
        return tables_attr

    def mysql2redis(self,redisobj):

        mysql_data = self.query_tables_info()

        for keys, values in mysql_data.items():
            # keys 为表名字
            for val in values:
                # val 为每一行的数据
                keysorted = sorted(val.keys())
                for s in keysorted:
                    #s 为数据的key
                    item = ‘%s:%s‘%(keys,str(val[‘id‘]))
                    ischange = redisobj.hgetkey(item,s)
                    if ischange != val[s]:
                        redisobj.hsetkey(item,s,val[s])

if __name__ == "__main__":

    queryalldata = QueryAllData()
    rhelper = RedisHelper()
    while True:
        queryalldata.mysql2redis(rhelper)

将mysql数据库中的单个库的数据同步到redis数据库中

标签:pipeline   打印   取数据   count   version   清空   members   cores   ==   

原文地址:https://www.cnblogs.com/HKROnline-SyncNavigator/p/10972542.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!