python操作数据库工具类

<pre name="code" class="python">#!/usr/bin/python  
# -*- coding: utf-8 -*-  

"""  
Created on 2016年11月5日  
  
@author: hongyi
1、执行带参数的ＳＱＬ时，请先用sql语句指定需要输入的条件列表，然后再用tuple/list进行条件批配  
2、在格式ＳＱＬ中不需要使用引号指定数据类型，系统会根据输入参数自动识别  
3、在输入的值中不需要使用转意函数，系统会自动处理  
"""    
     
import MySQLdb     
import Config    
import sys  
from MySQLdb.cursors import DictCursor    
from DBUtils.PooledDB import PooledDB   
reload(sys)  
sys.setdefaultencoding('utf-8')  
  
"""  
Config是一些数据库的配置文件  
"""    
     
class Mysql(object):    
    """  
    MYSQL数据库对象，负责产生数据库连接 , 此类中的连接采用连接池实现获取连接对象：conn = Mysql.getConn()  
            释放连接对象;conn.close()或del conn  
    """    
    #连接池对象    
    __pool = None    
    def __init__(self):    
        #数据库构造函数，从连接池中取出连接，并生成操作游标    
        try:  
            self._conn = Mysql.__getConn()    
            self._cursor = self._conn.cursor()   
        except Exception, e:  
            error = 'Connect failed! ERROR (%s): %s' %(e.args[0],e.args[1])  
            print error  
            sys.exit()  
  
   
    @staticmethod    
    def __getConn():    
        """  
        @summary: 静态方法，从连接池中取出连接  
        @return MySQLdb.connection  
        """    
        if Mysql.__pool is None:    
            __pool = PooledDB(creator=MySQLdb, mincached=1 , maxcached=20 ,    
                              host=Config.DBHOST , 
                              port=Config.DBPORT ,
                              user=Config.DBUSER , 
                              passwd=Config.DBPWD ,    
                              db=Config.DBNAME,
                              use_unicode=False,
                              charset=Config.DBCHAR,
                              cursorclass=DictCursor)    
        return __pool.connection()    
     
    #针对读操作返回结果集  
    def _exeCute(self,sql=''):  
        try:  
            self._cursor.execute(sql)  
            records = self._cursor.fetchall()  
            return records  
        except MySQLdb.Error,e:  
            error = 'MySQL execute failed! ERROR (%s): %s' %(e.args[0],e.args[1])  
            print error  
  
    #针对更新,删除,事务等操作失败时回滚  
    def _exeCuteCommit(self,sql='',arg=None): 
        try:  
            if arg is None:    
                self._cursor.execute(sql)    
            else:    
                self._cursor.execute(sql,arg)
            self._conn.commit()  
        except MySQLdb.Error,e:  
            self._conn.rollback()  
            error = 'MySQL execute failed! ERROR (%s): %s' %(e.args[0],e.args[1])  
            print error  
            #sys.exit()  
  
    #创建表          
    #tablename:表名称,attr_dict:属性键值对,constraint:主外键约束  
    #attr_dict:{'book_name':'varchar(200) NOT NULL'...}  
    #constraint:PRIMARY KEY(`id`)  
    def _createTable(self,table,attr_dict,constraint):  
        sql = ''  
        # sql_mid = '`row_id` bigint(11) NOT NULL AUTO_INCREMENT,'  
        sql_mid = ''
        for attr,value in attr_dict.items():  
            sql_mid = sql_mid + '`'+attr + '`'+' '+ value+','  
        sql = sql + 'CREATE TABLE IF NOT EXISTS %s ('%table  
        sql = sql + sql_mid  
        sql = sql + constraint  
        sql = sql + ') ENGINE=InnoDB DEFAULT CHARSET=utf8'  
        print '_createTable:'+sql  
        self._exeCuteCommit(sql)  
  
    def insertOne(self,sql,value=None):    
        """  
        @summary: 向数据表插入一条记录  
        @param sql:要插入的ＳＱＬ格式  
        @param value:要插入的记录数据tuple/list  
        @return: insertId 受影响的行数  
        """    
        self._exeCuteCommit(sql,value)
        return self.__getInsertId() 


    def _insert(self,table,attrs,value):
        """
        @summary: 向数据表插入一条记录 
        @param attrs = [] :要插入的属性
        @param value = [] :要插入的数据值 
        """  
        #values_sql = ['%s' for v in attrs]  
        attrs_sql = '('+','.join(attrs)+')'  
        value_str = self._transferContent(value)
        values_sql = ' values('+  value_str +')' 
        sql = 'insert into %s' %table  
        sql = sql + attrs_sql +  values_sql  
        print '_insert:'+sql  
        self._exeCuteCommit(sql)  


    def _insertDic(self,table,attrs):
        """
        @summary: 向数据表插入一条记录 
        @param attrs = {"colNmae:value"} :要插入的属性：数据值
        """  
        attrs_sql = '('+','.join(attrs.keys())+')'  
        value_str = self._transferContent(attrs.values()) #','.join(attrs.values())
        values_sql = ' values('+ value_str  +')' 
        sql = 'insert into %s' %table  
        sql = sql + attrs_sql +  values_sql  
        print '_insert:'+sql  
        self._exeCuteCommit(sql) 
  
    #将list转为字符串
    def _transferContent(self, content):
        if content is None:
            return None
        else:
            Strtmp = ""
            for col in content:
                if Strtmp == "":
                    Strtmp = "\"" + col + "\""
                else:
                    Strtmp += "," + "\"" + col + "\""
            return Strtmp
    
  
    def _insertMany(self,table,attrs,values): 
        """
        @summary: 向数据表插入多条数据  
        @param attrs = [id,name,...]  :要插入的属性
        @param values = [[1,'jack'],[2,'rose']] :要插入的数据值
        """  
        values_sql = ['%s' for v in attrs]  
        attrs_sql = '('+','.join(attrs)+')'  
        values_sql = ' values('+','.join(values_sql)+')'  
        sql = 'insert into %s'%table  
        sql = sql + attrs_sql + values_sql  
        print '_insertMany:'+sql  
        try:  
            for i in range(0,len(values),20000):  
                self._cursor.executemany(sql,values[i:i+20000])  
                self._conn.commit()  
        except MySQLdb.Error,e:  
            self._conn.rollback()  
            error = '_insertMany executemany failed! ERROR (%s): %s' %(e.args[0],e.args[1])  
            print error  
            sys.exit()  

    def insertMany(self,sql,values=None):    
        """  
        @summary: 向数据表插入多条记录  
        @param sql:要插入的ＳＱＬ格式  
        @param values:要插入的记录数据tuple(tuple)/list[list]  
        @return: count 受影响的行数  
        """
        try:  
            if values is None:    
                count = self._cursor.executemany(sql)    
            else:    
                count =  self._cursor.execute(sql,values)
            self._conn.commit()  
        except MySQLdb.Error,e:  
            self._conn.rollback()  
            error = 'MySQL execute failed! ERROR (%s): %s' %(e.args[0],e.args[1])  
            print error  
            sys.exit() 
        return count

    
    def _select(self,table,cond_dict='',order=''): 
        """
        @summary: 执行条件查询，并取出所有结果集
        @cond_dict:{'name':'xiaoming'...}  
        @order:'order by id desc'
        @return:  result ({"col":"val","":""},{})
        """ 
        consql = ' '  
        if cond_dict!='':  
            for k,v in cond_dict.items():  
                consql = consql+k+'='+v+' and'  
        consql = consql + ' 1=1 '  
        sql = 'select * from %s where '%table  
        sql = sql + consql + order  
        print '_select:'+sql  
        return self._exeCute(sql)  

    def __getInsertId(self):    
        """  
        获取当前连接最后一次插入操作生成的id,如果没有则为０  
        """    
        self._cursor.execute("SELECT @@IDENTITY AS id")    
        result = self._cursor.fetchall()    
        return result[0]['id']    
     
    def __query(self,sql,param=None):    
        if param is None:    
            count = self._cursor.execute(sql)    
        else:    
            count = self._cursor.execute(sql,param)    
        return count   

    def getAll(self,sql,param=None):    
        """  
        @summary: 执行查询，并取出所有结果集  
        @param sql:查询ＳＱＬ，如果有查询条件，请只指定条件列表，并将条件值使用参数[param]传递进来  
        @param param: 可选参数，条件列表值（元组/列表）  
        @return: result list(字典对象)/boolean 查询到的结果集 
        """    
        if param is None:    
            count = self._cursor.execute(sql)    
        else:    
            count = self._cursor.execute(sql,param)    
        if count>0:    
            result = self._cursor.fetchall()    
        else:    
            result = False    
        return result    
     
    def getOne(self,sql,param=None):    
        """  
        @summary: 执行查询，并取出第一条  
        @param sql:查询ＳＱＬ，如果有查询条件，请只指定条件列表，并将条件值使用参数[param]传递进来  
        @param param: 可选参数，条件列表值（元组/列表）  
        @return: result list/boolean 查询到的结果集  
        """    
        if param is None:    
            count = self._cursor.execute(sql)    
        else:    
            count = self._cursor.execute(sql,param)    
        if count>0:    
            result = self._cursor.fetchone()    
        else:    
            result = False    
        return result    
     
    def getMany(self,sql,num,param=None):    
        """  
        @summary: 执行查询，并取出num条结果  
        @param sql:查询ＳＱＬ，如果有查询条件，请只指定条件列表，并将条件值使用参数[param]传递进来  
        @param num:取得的结果条数  
        @param param: 可选参数，条件列表值（元组/列表）  
        @return: result list/boolean 查询到的结果集  
        """    
  
        count = self.__query(sql,parm)
        if count>0:    
            result = self._cursor.fetchmany(num)    
        else:    
            result = False    
        return result    
     
 
     
    def update(self,sql,param=None):    
        """  
        @summary: 更新数据表记录  
        @param sql: ＳＱＬ格式及条件，使用(%s,%s)  
        @param param: 要更新的  值 tuple/list  
        @return: count 受影响的行数  
        """    
        return self._exeCuteCommit(sql,param)    
     
    def delete(self,sql,param=None):    
        """  
        @summary: 删除数据表记录  
        @param sql: ＳＱＬ格式及条件，使用(%s,%s)  
        @param param: 要删除的条件 值 tuple/list  
        @return: count 受影响的行数  
        """    
        return self._exeCuteCommit(sql,param)    
     
    def begin(self):    
        """  
        @summary: 开启事务  
        """    
        self._conn.autocommit(0)    
     
    def end(self,option='commit'):    
        """  
        @summary: 结束事务  
        """    
        if option=='commit':    
            self._conn.commit()    
        else:    
            self._conn.rollback()    
     
    def dispose(self,isEnd=1):    
        """  
        @summary: 释放连接池资源  
        """    
        if isEnd==1:    
            self.end('commit')    
        else:    
            self.end('rollback');    
        self._cursor.close()    
        self._conn.close()