python环境测试MySQLdb、DBUtil、sqlobject性能
python环境测试MySQLdb、DBUtil、sqlobject性能
首先介绍下MySQLdb、DBUtil、sqlobject：python
（1）MySQLdb 是用于Python链接Mysql数据库的接口，它实现了 Python 数据库
API 规范 V2.0，基于 MySQL C API 上创建的。除了MySQLdb外，python还能够经过oursql, PyMySQL, myconnpy等模块实现MySQL数据库操做；mysql
（2）DBUtil中提供了几种链接池，用以提升数据库的访问性能，例如PooledDB,PesistentDB等sql
（3）sqlobject能够实现数据库ORM映射的第三方模块，能够以对象、实例的方式轻松操做数据库中记录。数据库
为测试这三者的性能，简单作一个例子：50个并发访问4000条记录的单表，数据库记录以下：编程
测试代码以下：并发
一、MySQLdb的代码以下，其中在connDB()中把链接池相关代码暂时作了一个注释，去掉这个注释既可使用链接池来建立数据库链接：ide
（1)DBOperator.py性能
01 |
import MySQLdb |
02 |
from stockmining.stocks.setting import LoggerFactory |
03 |
import connectionpool |
04 |
05 |
class DBOperator(object): |
06 |
|
07 |
def __init__(self): |
08 |
self.logger = LoggerFactory.getLogger('DBOperator') |
09 |
self.conn = None |
10 |
|
11 |
def connDB(self): |
12 |
self.conn=MySQLdb.connect(host="127.0.0.1",user="root",passwd="root",db="pystock",port=3307,charset="utf8") |
13 |
#当须要使用链接池的时候开启 |
14 |
#self.conn=connectionpool.pool.connection() |
15 |
return self.conn |
16 |
17 |
def closeDB(self): |
18 |
if(self.conn != None): |
19 |
self.conn.close() |
20 |
|
21 |
def execute(self, sql): |
22 |
try: |
23 |
if(self.conn != None): |
24 |
cursor = self.conn.cursor() |
25 |
else: |
26 |
raise MySQLdb.Error('No connection') |
27 |
|
28 |
n = cursor.execute(sql) |
29 |
return n |
30 |
except MySQLdb.Error,e: |
31 |
self.logger.error("Mysql Error %d: %s" % (e.args[0], e.args[1])) |
32 |
|
33 |
def findBySQL(self, sql): |
34 |
try: |
35 |
if(self.conn != None): |
36 |
cursor = self.conn.cursor() |
37 |
else: |
38 |
raise MySQLdb.Error('No connection') |
39 |
|
40 |
cursor.execute(sql) |
41 |
rows = cursor.fetchall() |
42 |
return rows |
43 |
except MySQLdb.Error,e: |
44 |
self.logger.error("Mysql Error %d: %s" % (e.args[0], e.args[1])) |
（2)测试代码testMysql.py，作了50个并发，对获取到的数据库记录作了个简单遍历。测试
01 |
import threading |
02 |
import time |
03 |
import DBOperator |
04 |
05 |
def run(): |
06 |
operator = DBOperator() |
07 |
operator.connDB() |
08 |
starttime = time.time() |
09 |
sql = "select * from stock_cash_tencent" |
10 |
peeps = operator.findBySQL(sql) |
11 |
for r in peeps: pass |
12 |
operator.closeDB() |
13 |
endtime = time.time() |
14 |
diff = (endtime - starttime)*1000 |
15 |
print diff |
16 |
|
17 |
def test(): |
18 |
for i in range(50): |
19 |
threading.Thread(target = run).start() |
20 |
time.sleep(1) |
21 |
|
22 |
if __name__ == '__main__': |
23 |
test() |
二、链接池相关代码：fetch
（1）connectionpool.py
01 |
from DBUtils import PooledDB |
02 |
import MySQLdb |
03 |
import string |
04 |
05 |
maxconn = 30 #最大链接数 |
06 |
mincached = 10 #最小空闲链接 |
07 |
maxcached = 20 #最大空闲链接 |
08 |
maxshared = 30 #最大共享链接 |
09 |
connstring="root#root#127.0.0.1#3307#pystock#utf8" #数据库地址 |
10 |
dbtype = "mysql" |
11 |
12 |
def createConnectionPool(connstring, dbtype): |
13 |
db_conn = connstring.split("#"); |
14 |
if dbtype=='mysql': |
15 |
try: |
16 |
pool = PooledDB.PooledDB(MySQLdb, user=db_conn[0],passwd=db_conn[1],host=db_conn[2],port=string.atoi(db_conn[3]),db=db_conn[4],charset=db_conn[5], mincached=mincached,maxcached=maxcached,maxshared=maxshared,maxconnections=maxconn) |
17 |
return pool |
18 |
except Exception, e: |
19 |
raise Exception,'conn datasource Excepts,%s!!!(%s).'%(db_conn[2],str(e)) |
20 |
return None |
21 |
22 |
23 |
pool = createConnectionPool(connstring, dbtype) |
三、sqlobject相关代码
（1）connection.py
1 |
from sqlobject.mysql import builder |
2 |
3 |
conn = builder()(user='root', password='root', |
4 |
host='127.0.0.1', db='pystock', port=3307, charset='utf8') |
（2)StockCashTencent.py对应到数据库中的表，50个并发并做了一个简单的遍历。（实际上，若是不作遍历，只作count()计算，sqlobject性能是至关高的。）
01 |
import sqlobject |
02 |
import time |
03 |
from connection import conn |
04 |
import threading |
05 |
06 |
class StockCashTencent(sqlobject.SQLObject): |
07 |
_connection = conn |
08 |
|
09 |
code = sqlobject.StringCol() |
10 |
name = sqlobject.StringCol() |
11 |
date = sqlobject.StringCol() |
12 |
main_in_cash = sqlobject.FloatCol() |
13 |
main_out_cash = sqlobject.FloatCol() |
14 |
main_net_cash = sqlobject.FloatCol() |
15 |
main_net_rate= sqlobject.FloatCol() |
16 |
private_in_cash= sqlobject.FloatCol() |
17 |
private_out_cash= sqlobject.FloatCol() |
18 |
private_net_cash= sqlobject.FloatCol() |
19 |
private_net_rate= sqlobject.FloatCol() |
20 |
total_cash= sqlobject.FloatCol() |
21 |
22 |
def test(): |
23 |
starttime = time.time() |
24 |
query = StockCashTencent.select(True) |
25 |
for result in query: pass |
26 |
endtime = time.time() |
27 |
diff = (endtime - starttime)*1000 |
28 |
print diff |
29 |
|
30 |
if __name__ == '__main__': |
31 |
for i in range(50): |
32 |
threading.Thread(target = test).start() |
33 |
time.sleep(1) |
测试结果以下：
| MySQLdb平均（毫秒） | 99.63999271 |
| DBUtil平均（毫秒） | 97.07998276 |
| sqlobject平均（毫秒） | 343.2999897 |
结论：其实就测试数据而言，MySQLdb单链接和DBUtil链接池的性能并无很大的区别（100个并发下也相差无几），相反sqlobject虽然具备的编程上的便利性，可是却带来性能上的巨大不足，在实际中使用哪一个模块就要斟酌而定了。