python3+ 连接并操作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. config[ 'server'] = {
  22. "write": {
  23. 'host': 'localhost',
  24. 'dbuser': 'root',
  25. 'dbpwd': '',
  26. 'port': 3306,
  27. 'dbname': 'liuyanben',
  28. 'dbprefix': 't_',
  29. },
  30. "read": {
  31. 'host': 'localhost',
  32. 'dbuser': 'root',
  33. 'dbpwd': '',
  34. 'port': 3306,
  35. 'dbname': 'liuyanben',
  36. 'dbprefix': 't_',
  37. }
  38. };
  39. return config;

 
 

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

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

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






评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值