python3+ 连接并操作mysql 数据库,支持读写分离

最新推荐文章于 2024-08-19 10:09:42 发布
转载 最新推荐文章于 2024-08-19 10:09:42 发布 · 449 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：https://blog.youkuaiyun.com/gyk163/article/details/78960747

本文分享了一个使用Python的pymysql库进行数据库操作的实战案例，包括读写分离配置、数据库查询、插入、更新和删除等基本操作。通过具体代码示例，展示了如何实现对MySQL数据库的高效管理和数据处理。 
                                  <p><span></span>最近，看了关于的一篇帖子，关于python的，决定花几天看下python的基本知识。看了基础知识后，发现记不住，就随手写了点代码，加深自己的记忆。</p>

暂时主要写了对数据库的操作，其他的都还没有做，后续会逐步完善，代码写的很基础，里面肯定还存在很多问题，自己保存起，怕后面丢失了。

主要是 pyMysql库 实现了对mysql数据库的操作，目前支持读写分离。




1、app_db.py对数据库的配置。 支持读写分离。


  1. def dbconfig() :
  2.     config = dict();
  3.     config['master'] = {
  4.         "write" : {
  5.              'host' : 'localhost',
  6.              'dbuser' : 'root',
  7.              'dbpwd' : '',
  8.              'port' : 3306,
  9.              'dbname' : 'liuyan',
  10.              'dbprefix' : 'ly_',
  11.         },
  12.         "read" : {
  13.             'host': 'localhost',
  14.             'dbuser': 'root',
  15.             'dbpwd': '',
  16.             'port': 3306,
  17.             'dbname': 'liuyan',
  18.             'dbprefix': 'ly_',
  19.         }
  20.     };
  21.  
  22.     config['server'] = {
  23.         "write": {
  24.             'host': 'localhost',
  25.             'dbuser': 'root',
  26.             'dbpwd': '',
  27.             'port': 3306,
  28.             'dbname': 'liuyanben',
  29.             'dbprefix': 't_',
  30.         },
  31.         "read": {
  32.             'host': 'localhost',
  33.             'dbuser': 'root',
  34.             'dbpwd': '',
  35.             'port': 3306,
  36.             'dbname': 'liuyanben',
  37.             'dbprefix': 't_',
  38.         }
  39.     };
  40.     return config;

2、app_db.py 实现对数据库的操作，支持读写分离。



  1. #@author  SteveGao
  2.  
  3.  
  4. import sys;
  5. import pymysql;
  6. import random;
  7. from config.app_db import dbconfig;
  8.  
  9. class DB :
  10.     link = dict();
  11.     _res = '';
  12.     _mode = "read";# write,read
  13.     _dbconfig = dbconfig();
  14.     _host = '';
  15.     def __init__(self,host = "master"):
  16.         self._host = host;
  17.  
  18.     def connect(self,mode = "read"):
  19.         try :
  20.             self._mode = mode;
  21.             self._dbconfig = self._dbconfig[self._host][self._mode];
  22.             self.host = self._dbconfig['host'];
  23.             self.dbuser = self._dbconfig['dbuser'];
  24.             self.password = self._dbconfig['dbpwd'];
  25.             self.dbname = self._dbconfig['dbname'];
  26.             self.port = self._dbconfig['port'];
  27.             self._res = pymysql.cursors.DictCursor;
  28.             self.link[self._host] = pymysql.connect(self.host,self.dbuser,self.password,self.dbname,self.port);
  29.         except Exception as err:
  30.             print("DBERR数据库连接失败： \n[%s]" %(err));
  31.             exit();
  32.  
  33.     def getTableName(self,tableName):
  34.         return self._dbconfig['dbprefix'] + tableName;
  35.  
  36.  
  37.     '''
  38.     查询单张表的一条记录
  39.     '''
  40.     def getOne(self,tableName,id):
  41.         try :
  42.             self.connect('read');
  43.             tableName = self.getTableName(tableName);
  44.             cursors = self.link[self._host].cursor(self._res);
  45.             sql = "SELECT * FROM %s WHERE id = %d LIMIT 1";
  46.             cursors.execute(sql %(tableName,int(id)));
  47.             result = cursors.fetchone();
  48.             return result;
  49.         except Exception as err:
  50.             print("DBERR数据库查询单条记录失败： \n[%s]" % (err));
  51.             exit();
  52.  
  53.     '''
  54.     根据条件查询单表的内容
  55.     '''
  56.     def getCondition(self,tableName, condition = ''):
  57.         try :
  58.             self.connect('read');
  59.             cursors = self.link[self._host].cursor(self._res);
  60.             tableName = self.getTableName(tableName);
  61.             if (condition):
  62.                 sql = "SELECT * FROM %s WHERE %s";
  63.                 cursors.execute(sql % (tableName, condition));
  64.             else :
  65.                 sql = "SELECT * FROM %s;";
  66.                 cursors.execute(sql % (tableName));
  67.  
  68.             result = cursors.fetchall();
  69.             result = list(result);
  70.             return result;
  71.         except Exception as err:
  72.             print("DBERR数据库按条件查询记录失败： \n[%s]" % (err));
  73.             exit();
  74.  
  75.  
  76.     '''
  77.     根据SQL语句查询
  78.     '''
  79.     def executeSql(self,sql,findOne = 'm'):
  80.         try :
  81.             sql = sql.lstrip();
  82.             if (len(sql) == 0):
  83.                 return False;
  84.  
  85.             operate = sql[0:6].upper();
  86.             if (operate == "SELECT"):
  87.                 self._mode = 'read';
  88.             elif (operate == 'INSERT' or operate == "UPDATE" or operate == 'DELETE') :
  89.                 self._mode = 'write';
  90.             else :
  91.                 self._mode = 'write';
  92.  
  93.             self.connect(self._mode);
  94.             cursors = self.link[self._host].cursor(self._res);
  95.  
  96.             execs = cursors.execute(sql);
  97.             if (operate == "SELECT") :
  98.                 if ((findOne == 'm') and ("LIMIT 1" not in sql.upper())) :
  99.                     result = cursors.fetchall();
  100.                 else :
  101.                     result = cursors.fetchone();
  102.                 return result;
  103.             else :
  104.                 return execs;
  105.  
  106.         except Exception as err:
  107.             print("DBERR数据库执行失败： \n[%s]" % (err));
  108.             exit();
  109.  
  110.     '''
  111.     使用字典插入单条数据
  112.     link = DB('localhost','root','','liuyan');
  113.     data = {"user_name":"stevegao","password" : "444444",'create_time':"2017-02-12 09:12:12", 'login_times' : "1"};
  114.     link.insertAll('ly_user',data);
  115.     '''
  116.     def insert(self,table,data):
  117.         try :
  118.             self.connect('write');
  119.             table = self.getTableName(table);
  120.             tinsert = "INSERT INTO %s";
  121.             fieldList = ' (';
  122.             valueList = ' (';
  123.             for field in data :
  124.                 fieldList += "`" + field + "`,";
  125.                 valueList += '"' + data[field] + '",';
  126.             fieldList = fieldList[0:-1] + ") ";
  127.             valueList = valueList[0:-1] + ") ";
  128.             sql = tinsert + fieldList + "values " + valueList;
  129.             cursors = self.link[self._host].cursor(self._res);
  130.             insert = cursors.execute(sql %(table));
  131.             print(sql %(table));
  132.             #self.link.commit();
  133.             return insert;
  134.         except Exception as err :
  135.             self.link.rollback();
  136.             print("DBERR数据库插入单条记录失败：\n[%s]" % (err));
  137.             exit();
  138.  
  139.  
  140.     '''
  141.     使用字典，批量插入数据到数据库
  142.     link = DB('localhost','root','','liuyan');
  143.     data = dict();
  144.     data[0] = {"user_name":"stevegao","password" : "444444",'create_time':"2017-02-12 09:12:12", 'login_times' : "1"};
  145.     data[1] = {"user_name":"jennygao","password" : "555555",'create_time':"2017-02-12 09:12:12", 'login_times' : "1"};
  146.     ii = link.insertAll('ly_user',data);
  147.     '''
  148.  
  149.     def insertAll(self,table,data):
  150.         try :
  151.             self.connect('write');
  152.             table = self.getTableName(table);
  153.             tinsert = "INSERT INTO %s";
  154.             fieldList = ' (';
  155.             values = '';
  156.             oneField = data[0];
  157.             for field in oneField:
  158.                 fieldList += "`" + field + "`,";
  159.             fieldList = fieldList[0:-1] + ") ";
  160.  
  161.             for row in data :
  162.                 valueList = '(';
  163.                 for field in data[row] :
  164.                     valueList += '"' + data[row][field] + '",';
  165.                 values += valueList[0:-1] + "),";
  166.  
  167.  
  168.             sql = tinsert + fieldList + "values " + values[0:-1];
  169.             cursors = self.link[self._host].cursor(self._res);
  170.             insert = cursors.execute(sql %(table));
  171.             #self.link.commit();
  172.             return insert;
  173.         except Exception as err:
  174.             self.link.rollback();
  175.             print("DBERR数据库批量插入记录失败：\n[%s]" % (err));
  176.             exit();
  177.  
  178.     def commit(self):
  179.         self.link[self._host].commit();
  180.  
  181.     def rollback(self):
  182.         self.link[self._host].rollback();
  183.  
  184.     '''
  185.     关闭数据库链接
  186.     '''
  187.     def close(self):
  188.         self.link[self._host].close();
  189.  
  190.  
  191.  
  192.  
3、app_model.py 支持链式操作，让开发变得 简单。



  1. #@author  SteveGao
  2.  
  3. from gyk.database.app_db import DB;
  4. from config.app_db import dbconfig;
  5.  
  6.  
  7.  
  8. '''
  9. 向数据库插入单条数据
  10. model = Model();
  11. data = {"user_name":"stevegao","password" : "444444",'create_time':"2017-02-12 09:12:12", 'login_times' : "1"};
  12. insert = model.table('ly_user').insert(data);
  13. if (insert) :
  14.     model.db.link.commit(); //提交事务
  15. else :
  16.     model.db.link.rollback(); //回滚事务
  17. '''
  18.  
  19. class Model :
  20.     lastsql = '';
  21.     _wherestr = '';
  22.     _orderstr = '';
  23.     _groupstr = '';
  24.     _limitstr = '';
  25.     _fieldstr = '';
  26.     _tablename = '';
  27.     _having = '';
  28.     _host = "";
  29.  
  30.     db = {};
  31.  
  32.     def __init__(self,host = "master"):
  33.  
  34.         self._host = host;
  35.         mysql = DB(host.lower()); #实例化数据库类
  36.         self.db[self._host] = mysql;
  37.  
  38.     def max(self,field):
  39.         sql = self._parseStatis('max',field);
  40.         self.lastsql = sql;
  41.         result = self.db[self._host].executeSql(sql);
  42.         return result;
  43.  
  44.     def min(self,field):
  45.         sql = self._parseStatis('min',field);
  46.         self.lastsql = sql;
  47.         result = self.db[self._host].executeSql(sql);
  48.         return result;
  49.  
  50.     def avg(self,field):
  51.         sql = self._parseStatis('avg',field);
  52.         self.lastsql = sql;
  53.         result = self.db[self._host].executeSql(sql);
  54.         return result;
  55.  
  56.     def count(self,field):
  57.         sql = self._parseStatis('count',field);
  58.         self.lastsql = sql;
  59.         result = self.db[self._host].executeSql(sql);
  60.         return result;
  61.  
  62.  
  63.     def sum(self,field):
  64.         sql = self._parseStatis('sum',field);
  65.         self.lastsql = sql;
  66.         result = self.db[self._host].executeSql(sql);
  67.         return result;
  68.  
  69.  
  70.     def table(self,tablename):
  71.         pconfig = dbconfig();
  72.         prefix = pconfig[self._host]['write']['dbprefix'];
  73.         self._tablename = "`" + prefix + tablename + "`";
  74.         return self;
  75.  
  76.     def where(self,where = ""):
  77.         if (where) :
  78.             self._wherestr = self._parseWhereDict(where);
  79.         else :
  80.             self._wherestr = where;
  81.         return self;
  82.  
  83.     def orderBy(self,order = ""):
  84.         self._orderstr = order;
  85.         return self;
  86.  
  87.     def groupBy(self,groupby = ""):
  88.         self._groupstr = groupby;
  89.         return self;
  90.  
  91.     def having(self,having = ""):
  92.         self._having = having;
  93.         return self;
  94.  
  95.     def limit(self,limit = ""):
  96.         self._limitstr = limit;
  97.         return self;
  98.  
  99.     def field(self,field = "*"):
  100.         self._fieldstr = field;
  101.         return self;
  102.  
  103.     def select(self):
  104.         sql = self._parseQuery();
  105.         self.lastsql = sql;
  106.         result = self.db[self._host].executeSql(sql);
  107.         return result;
  108.  
  109.     def find(self):
  110.         sql = self._parseQuery(1);
  111.         self.lastsql = sql;
  112.         result = self.db[self._host].executeSql(sql,'s');
  113.         return result;
  114.  
  115.     def query(self,sql):
  116.         self.lastsql = sql;
  117.         result = self.db[self._host].executeSql(sql);
  118.         return result;
  119.  
  120.     '''
  121.     插入单条数据，data类型为字典型
  122.     '''
  123.     def insert(self,data):
  124.         sql = self._parseInsert(data);
  125.         self.lastsql = sql;
  126.         result = self.db[self._host].executeSql(sql);
  127.         return result;
  128.  
  129.     '''
  130.     批量插入数据，data类型为字典型
  131.     '''
  132.     def insertAll(self,data):
  133.         sql = self._parseInsertAll(data);
  134.         if (sql == False) :
  135.             return sql;
  136.         self.lastsql = sql;
  137.         result = self.db[self._host].executeSql(sql);
  138.         return result;
  139.  
  140.     def delete(self):
  141.         sql = self._parseDelete();
  142.         self.lastsql = sql;
  143.         result = self.db[self._host].executeSql(sql, 's');
  144.         return result;
  145.  
  146.     def update(self,data):
  147.         sql = self._parseSetDict(data);
  148.         self.lastsql = sql;
  149.         result = self.db[self._host].executeSql(sql, 's');
  150.         return result;
  151.  
  152.     '''
  153.     提交事务
  154.     '''
  155.  
  156.     def commit(self):
  157.         self.db[self._host].commit();
  158.  
  159.     '''
  160.     提交回滚
  161.     '''
  162.  
  163.     def rollback(self):
  164.         self.db[self._host].rollback();
  165.  
  166.     '''
  167.     解析查询语句
  168.     '''
  169.     def _parseQuery(self,limit = 2):
  170.         tempsql = "";
  171.         tempsql = "SELECT ";
  172.         if (self._fieldstr) :
  173.             tempsql += self._fieldstr;
  174.         else :
  175.             tempsql += "*";
  176.         tempsql += " FROM ";
  177.  
  178.         if (self._tablename) :
  179.             tempsql += self._tablename;
  180.  
  181.         if (self._wherestr):
  182.             tempsql += " WHERE ";
  183.             tempsql += self._wherestr;
  184.  
  185.         tempsql += " ";
  186.  
  187.         if (self._groupstr):
  188.             tempsql += " GROUP BY ";
  189.             tempsql += self._groupstr;
  190.  
  191.         if (self._having) :
  192.             tempsql += " HAVING ";
  193.             tempsql += self._having;
  194.  
  195.         if (self._orderstr):
  196.             tempsql += " ORDER BY ";
  197.             tempsql += self._orderstr;
  198.         tempsql += " ";
  199.  
  200.         if (limit == 2) :
  201.             if (self._limitstr):
  202.                 tempsql += " LIMIT ";
  203.                 tempsql += self._limitstr;
  204.         else :
  205.             tempsql += " LIMIT 1";
  206.  
  207.         return tempsql;
  208.  
  209.  
  210.     def _parseInsert(self,data):
  211.         tinsert = "";
  212.         tinsert += "INSERT INTO ";
  213.  
  214.         if (self._tablename) :
  215.             tinsert += self._tablename;
  216.  
  217.         fieldList = ' (';
  218.         valueList = ' (';
  219.         for field in data:
  220.             fieldList += "`" + field + "`,";
  221.             valueList += '"' + data[field] + '",';
  222.         fieldList = fieldList[0:-1] + ") ";
  223.         valueList = valueList[0:-1] + ") ";
  224.         sql = tinsert + fieldList + "values " + valueList;
  225.         return sql;
  226.  
  227.     def _parseInsertAll(self,data):
  228.         if (data.get(0) == None) :
  229.             return False;
  230.         tinsert = "";
  231.         tinsert += "INSERT INTO ";
  232.         if (self._tablename) :
  233.             tinsert += "`" +self._tablename + "`";
  234.         fieldList = ' (';
  235.         values = '';
  236.         oneField = data[0];
  237.         for field in oneField:
  238.             fieldList += "`" + field + "`,";
  239.         fieldList = fieldList[0:-1] + ") ";
  240.  
  241.         for row in data:
  242.             valueList = '(';
  243.             for field in data[row]:
  244.                 valueList += '"' + data[row][field] + '",';
  245.             values += valueList[0:-1] + "),";
  246.  
  247.         sql = tinsert + fieldList + "VALUES " + values[0:-1];
  248.         return sql;
  249.  
  250.     '''
  251.         解析查询语句
  252.         '''
  253.  
  254.     def _parseStatis(self,func,field):
  255.         tempsql = "";
  256.         tempsql = "SELECT ";
  257.         if (field):
  258.             tempsql += func +"(" + field +")";
  259.         else:
  260.             tempsql += func +"(" + 1 +")";
  261.         tempsql += " FROM ";
  262.  
  263.         if (self._tablename):
  264.             tempsql += self._tablename;
  265.  
  266.         if (self._wherestr):
  267.             tempsql += " WHERE ";
  268.             tempsql += self._wherestr;
  269.  
  270.         tempsql += " ";
  271.  
  272.         if (self._groupstr):
  273.             tempsql += " GROUP BY ";
  274.             tempsql += self._groupstr;
  275.  
  276.         if (self._having) :
  277.             tempsql += " HAVING ";
  278.             tempsql += self._having;
  279.  
  280.         if (self._orderstr):
  281.             tempsql += " ORDER BY ";
  282.             tempsql += self._orderstr;
  283.         tempsql += " ";
  284.         if (self._groupstr == "") :
  285.             tempsql += " LIMIT 1";
  286.  
  287.         return tempsql;
  288.  
  289.  
  290.     def _parseDelete(self):
  291.  
  292.         tempsql = "";
  293.         tempsql = "DELETE ";
  294.         tempsql += " FROM ";
  295.  
  296.         if (self._tablename):
  297.             tempsql += self._tablename;
  298.  
  299.         if (self._wherestr):
  300.             tempsql += " WHERE ";
  301.             tempsql += self._wherestr;
  302.  
  303.         tempsql += " ";
  304.  
  305.         if (self._orderstr):
  306.             tempsql += " ORDER BY ";
  307.             tempsql += self._orderstr;
  308.         tempsql += " ";
  309.  
  310.         if (self._limitstr):
  311.             tempsql += " LIMIT ";
  312.             tempsql += self._limitstr;
  313.  
  314.         return tempsql;
  315.  
  316.     def _parseUpdate(self,data):
  317.  
  318.         if (not data) :
  319.             return False;
  320.  
  321.         tempsql = "";
  322.         tempsql = "UPDATE ";
  323.  
  324.         if (self._tablename):
  325.             tempsql += self._tablename;
  326.  
  327.         tempsql += " SET ";
  328.  
  329.         tempsql += self._parseDict(data);
  330.  
  331.         if (self._wherestr):
  332.             tempsql += " WHERE ";
  333.             tempsql += self._wherestr;
  334.  
  335.         tempsql += " ";
  336.  
  337.         if (self._orderstr):
  338.             tempsql += " ORDER BY ";
  339.             tempsql += self._orderstr;
  340.         tempsql += " ";
  341.  
  342.         if (self._limitstr):
  343.             tempsql += " LIMIT ";
  344.             tempsql += self._limitstr;
  345.  
  346.         return tempsql;
  347.  
  348.     def _parseSetDict(self,data):
  349.         result = "";
  350.         if (isinstance(data, dict)):
  351.             temp = "";
  352.             for field in data :
  353.                 temp += '`' + field + '` = "' + data[field] + '",';
  354.             result = temp[0:-1];
  355.         else :
  356.             result = data;
  357.         return  result;
  358.  
  359.     def _parseWhereDict(self,data):
  360.         result = "";
  361.         if (isinstance(data, dict)):
  362.             temp = "";
  363.             for field in data :
  364.                 temp += '`' + field + '` = "' + data[field] + '" AND ';
  365.             result = temp.rstrip()[0:-3];
  366.         else :
  367.             result = data;
  368.         return  result;
  369.  
  370.  
  371.  















                                    
                    
    
    
 
        

            



                

                
                
        

    


  



    



                



	

		

			

				
					
Python实现mysql数据库读写分离

				
			

			

				

					qq_52583721的博客
				

				

					11-20
					
					901
					
				

			

		

		

			
				
之前写了一个mysql主从同步，那么做了这个同步之后，在它的基础上，我们做读写分离这个操作就比较简单了。
读写分离，顾名思义，我们可以把读和写两个操作分开，减轻数据的访问压力，解决高并发的问题。
那么我们今天就Python两大框架来做这个读写分离的操作。
1.Django框架实现读写分离
Django做读写分离非常的简单，直接在settings.py中把从机加入到数据库的配置文件中就可以了。
DATABASES = {
‘default’: {
‘ENGINE’: ‘django.db.backends.m

			
		

	



                

            
              



	

		

			

				
					
python管理mysql（实现读写分离）及如何用Mycat读写分离

				
			

			

				

					m0_74614835的博客
				

				

					08-15
					
					945
					
				

			

		

		

			
				
bash: /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/root/bin:/usr/local/jdk/bin: 没有那个文件或目录。drwxr-xr-x. 7 root root 85 8月  15 15:20 /usr/local/mycat/-rwxr-xr-x. 1 root root  219 8月  15 15:20 version.txt。# __init__ 初始化函数，构造函数，在这个类被实例的时候，执行__init__函数。

			
		

	



              


  
              

                


	

		

			

				
					
Python3.6 使用pymysql库操作mysql，实现读写分离

				
			

			

				

					01-08
				

			

		

		

			
				
用python3 引入pymysql库，实现对mysql数据库的操作，支持数据库的读写分离配置。仅限数据库的操作。
实现了基本的链式操作，比如：
model = new Model();
model.table("表").field("字段").where("条件").orderBy("排序").select();     #查询多条数据

			
		

	





	

		

			

				
					
Mysql读写分离 python_Python实现mysql数据库读写分离

				
			

			

				

					weixin_42521649的博客
				

				

					01-21
					
					313
					
				

			

		

		

			
				
之前写了一个mysql主从同步，那么做了这个同步之后，在它的基础上，我们做读写分离这个操作就比较简单了。读写分离，顾名思义，我们可以把读和写两个操作分开，减轻数据的访问压力，解决高并发的问题。那么我们今天就Python两大框架来做这个读写分离的操作。1.Django框架实现读写分离Django做读写分离非常的简单，直接在settings.py中把从机加入到数据库的配置文件中就可以了。DATABAS...

			
		

	



		

			
		



	

		

			

				
					
Django连接数据库并实现读写分离过程解析

				
			

			

				

					09-18
				

			

		

		

			
				
总的来说，Django项目实现读写分离是一个涉及多个层面的技术实践，需要开发者对Django框架、数据库配置和运维支持有一个全面的理解。通过本文的介绍，我们可以看到Django为实现读写分离提供了丰富的工具和灵活的配置...

			
		

	





	

		

			

				
					
python实现mysql的读写分离及负载均衡

				
			

			

				

					12-23
				

			

		

		

			
				
Oracle数据库有其公司开发的配套rac来实现负载均衡，目前已知的最大节点数能到128个，但是其带来的维护成本无疑是很高的，并且rac的稳定性也并不是特别理想，尤其是节点很多的时候。  但是，相对mysql来说，rac的...

			
		

	





	

		

			

				
					
对MySQL数据库读写分离的两种方法

				
			

			

				

					weixin_69088860的博客
				

				

					08-15
					
					819
					
				

			

		

		

			
				
中插入数据，不能创建，一直卡在插入数据的那里，插不进去，一旦解锁，配置后端真实有效的用户、密码、真实数据库名称等信息。的对外的用户、密码、映射数据库名称等信息。查看状态信息，查到是空的话是因为没有写。查看端口（有端口就是启动成功了）补充（报错的话查看错误日志）用户给权限（不能执行，因为。修改配置文件（从数据库）语句就会立马执行成功。执行查询数据库的语句。停止服务（主数据库）查看主从配置详细信息。名称为真的是数据库名称。将查到的语句进行打印。

			
		

	





	

		

			

				
					
Python项目实战 10.2：性能优化：MySQL读写分离

				
			

			

				

					mengnf的专栏
				

				

					01-19
					
					1378
					
				

			

		

		

			
				
Python项目实战：性能优化：MySQL读写分离


			
		

	





	

		

			

				
					
python 实现对MySQL 主从复制与读写分离 --2023博客之星候选--城市赛道

				
			

			

				

					weixin_45471729的博客
				

				

					06-28
					
					593
					
				

			

		

		

			
				
python实现MySQL主从复制与读写分离简单示例

			
		

	





	

		

			

				
					
mysql 实现读写分离_MySql读写分离实现

				
			

			

				

					weixin_39960116的博客
				

				

					01-18
					
					199
					
				

			

		

		

			
				
技术原理为什么？进行中的项目，有大量的第三方数据频繁的写入，影响了读的效率。通过读写分离，可以实现读锁和写锁的竞争。读锁和写锁可以具体网上找其他资源了解。怎么做？1. 主从复制：主数据库有写操作，从数据库自动同步。从数据库通过I/O线程去请求主数据库的binlog日志文件(二进制日志，包含SQL的增删改查等，用来做备份恢复等)，并写到中继日志中，SQL线程会读取中继日志，并解析成具体操作同步数据到...

			
		

	





	

		

			

				
					
mysql读写分离

				
			

			

				

					程序猿劝退师的博客
				

				

					08-27
					
					1071
					
				

			

		

		

			
				
目录

1.背景介绍

1.1web层

1.2数据访问层

2.软件环境

3.配置Master主服务器(Window)

3.1创建帐号授权

3.2修改my.Ini文件。

3.3查看Master状态

4、配置Slave从服务器（Linux）

4.1修改my.cnf文件,vim /etc/my.cnf

4.2重启mysql服务：

4.3连接Master

4.4启动Slave

4....

			
		

	





	

		

			

				
					
MySQL Proxy 实现 MySQL 读写分离提高并发负载

				
			

			

				

					weixin_30377461的博客
				

				

					09-16
					
					200
					
				

			

		

		

			
				
工作拓扑：

MySQL Proxy有一项强大功能是实现“读写分离”，基本原理是让主数据库处理写方面事务，让从库处理SELECT查询。
Amoeba for MySQL是一款优秀的中间件软件，同样可以实现读写分离，负载均衡等功能，并且稳定性也高于MySQL Proxy，有兴趣的可以测试一下。
环境描述：

操作系统：CentOS6.3_x64
主服务器Master：192.168.0...

			
		

	





	

		

			

				
					
python mysql proxy_最近写的一个mysql读写分离的，python 小工具：angel  mysql proxy

				
			

			

				

					weixin_32001071的博客
				

				

					02-03
					
					570
					
				

			

		

		

			
				
mysql 读写分离在面对一定的数据库压力下，的确有一定的帮助，读写分离方面的程序似乎也很多，mysql 官方也有个读写分离产品叫MySQL Proxy 。 按照我理解，似乎实现基本的读写分离也不是很难。所以我按照自己的想法写了一个。目前在并发600的情况下是成功的。并发超过600后就有收割僵尸进程不完成的情况，导致进程假死状态。这个目前有个解决想法，就是把收割程序独立出来用一个进程来专门收割，这...

			
		

	





	

		

			

				
					
29 python脚本使数据库读写分离，mysql主从开机自动同步，python操作数据库，MyCat插件的学习

				
			

			

				

					2301_79379541的博客
				

				

					08-19
					
					1077
					
				

			

		

		

			
				
例如，如果一个数据库中的表数据量非常大，查询性能下降，通过 MyCat 可以将该表的数据按照一定的规则（如按照主键范围、哈希值等）分布到多个数据库节点上，从而减轻单个节点的负载，提高查询效率。-bash: /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/usr/local/jdk/bin: 没有那个文件或目录。此外，它提供了一些高级功能，如数据的聚合、排序、分页等，使得在分布式环境下进行复杂的数据库操作变得更加容易。

			
		

	





	

		

			

				
					
sqlalchemy对MySQL的读写_【广州python】使用flask-sqlalchemy 实现mysql读写分离

				
			

			

				

					weixin_31174767的博客
				

				

					02-11
					
					203
					
				

			

		

		

			
				
[Python] 纯文本查看 复制代码import threadingfrom contextlib import contextmanagerfrom frame.orm.db_util import get_db_sessionmaker, Basefrom utils.collection_util import is_emptyfrom utils.random_util import r...

			
		

	





	

		

			

				
					
mysql主从同步与读写分离

				
			

			

				

					qq_42890862的博客
				

				

					07-23
					
					306
					
				

			

		

		

			
				
主从同步：
一、配置主数据库
1、安装数据库并启动、设置为自动启动
[root@x4d000005 /]# yum install -y mariadb mariadb-server python2-PyMySQL -y
[root@x4d000005 /]# systemctl start mariadb.service
[root@x4d000005 /]# systemctl enable mariadb.service
2、初始化
[root@x4d000005 /]# mysql_secure_i

			
		

	





	

		

			

				
					
在Python的Django框架中实现MySQL数据库的读写分离，并结合Redis进行性能优化，应该如何操作？

					
最新发布

				
			

			

				

					10-28
				

			

		

		

			
				
书中详细介绍了易果生鲜电商系统是如何在Django框架下实现MySQL数据库的读写分离，并通过结合Redis技术优化整体性能的。  参考资源链接：[易果生鲜电商系统：Python开发的创新项目与技术应用]...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

  
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值