sqlalchemy的接口

from sqlalchemy import create_engine
# from sqlalchemy.pool import NullPool
from sqlalchemy.orm import sessionmaker


class API(object):

    '''
    定义orm框架的api接口，实现增删改查的功能
    '''

    # 监控模型类对象生成过程，并且对mysql
    # 数据库的创建进行判断，生成mysql数据库中的数据表
    # 对象初始化
    def __init__(self):

        # args = 'mysql://root:shen123@localhost/test?charset=utf8'
        args = 'mysql+pymysql://root:shen123@localhost:3306/test1'
        # 创建数据库链接引擎
        engine = create_engine(args)
        # 返回数据库会话
        Session = sessionmaker(bind=engine)
        # 创建数据库会话对象
        self.session = Session()

    # 增加
    def add(self,db,value):

        # 对模型类进行实例化对象
        obj = db()
        # 保存到数据库，异常回滚
        obj.name = value
        try:
            # 保存到数据库
            self.session.add(obj)
            # 保存对象后进行提交
            self.session.commit()
        except:
            # 出现异常回滚
            self.session.rollback()

    # 删除
    def dele(self,db,**kwargs):

        # 实例化对象
        obj = db()
        # 对接受到的不定长参数进行判断
        if kwargs is not None:
            # 对传递进来的字段条件进行遍历，判断是否正确
            for key in kwargs.keys():
                # 获取模型类对象的属性，如果属性存在则返回为None，不存在返回Notexist
                resu = getattr(obj, key, 'Notexist')
                # 判断返回值返回的结果
                if resu == 'Notexist':
                    # 返回不存在的模型类字段并推出
                    return ('%s is not defined' % key)
        # 根据模型类的字段值进行查询，没有结果返回为None，有结果会返回对象地址
        res = self.session.query(db).filter_by(**kwargs).first()
        # 对查询结果进行判断，如果有数据向下执行，没有数据则返回不催在
        if res:
            try:
                # 对查询的对象进行删除操作
                self.session.delete(res)
                # 删除对象后进行提交
                self.session.commit()
                # 返回删除成功
                return 'Success'

            except:
                # 删除异常进行事务回滚
                self.session.rollback()
        else:
            # 返回不存在
            return 'NoExist'

    # 清空数据表
    def dele_all(self,db):

        # 查询所有的对象
        ret = self.session.query(db).all()
        # 如果存在数据
        if ret:
            # 遍历对象列表
            for obj in ret:
                try:
                    # 删除对象
                    self.session.delete(obj)
                    # 删除后提交保存
                    self.session.commit()
                except:
                    # 异常回滚
                    self.session.rollback()
                    return 'False'
        else:
            # 不存在数据返回为空
            return 'Null'

    #改
    def change(self,db,content,**kwargs):

        # 实例化对象
        obj = db()
        # 对接受到的不定长参数进行判断
        if kwargs is not None:
            # 对传递进来的字段条件进行遍历，判断是否正确
            for key in kwargs.keys():
                # 获取模型类对象的属性，如果属性存在则返回为None，不存在返回Notexist
                resu = getattr(obj, key, 'Notexist')
                # 判断返回值返回的结果
                if resu == 'Notexist':
                    # 返回不存在的模型类字段并推出
                    return ('%s is not defined' % key)
        # 对更改数据的查询和更改进行异常判断
        try:
            # 查询要更新的 对象模型是否存在，存在则返回对象地址，不存在返回None
            ret = self.session.query(db).filter_by(**kwargs).first()
            # 更新对象的属性内容
            ret.name = content
            # 更新后提交保存人数据库
            self.session.commit()
            return 'OK'
        except:
            # 出现异常，事务回滚
            self.session.rollback()


    # 按条件查询一条数据
    def find(self,db,**kwargs):

        # 实例化对象
        obj = db()
        # 对接受到的不定长参数进行判断
        if kwargs is not None:
            # 对传递进来的字段条件进行遍历，判断是否正确
            for key in kwargs.keys():
                # 获取模型类对象的属性，如果属性存在则返回为None，不存在返回Notexist
                resu = getattr(obj, key, 'Notexist')
                # 判断返回值返回的结果
                if resu == 'Notexist':
                    # 返回不存在的模型类字段并推出
                    return ('%s is not defined' % key)
        try:
            # 查询要更新的 对象模型是否存在，存在则返回对象地址，不存在返回None
            res = self.session.query(db).filter_by(**kwargs).first()
        except:
            # 出现异常事务回滚
            self.session.rollback()
        # 如果查询到了对象
        if res:
            # 获取到的对象调用__dict__以字典类型键值对的格式返回属性
            su = res.__dict__
            # 删除对象地址内存键值对
            su.pop('_sa_instance_state')
            # 打印输出对象
            print(su)
            # 以字典的形式返回对象的属性
            return su

        else:
            # 否则返回不存在
            return 'NoExist'

    # 查询所有的对象
    def find_all(self,db):

        # 查询所有的数据
        try:
            # 查询所有的数据
            ret = self.session.query(db).all()
            # 对查询到的数据进行判断为空返回null,有数据返回的是一个对象列表
            if ret:
                # 对模型对象列表进行遍历
                for obj in ret:
                    # 获取到的对象调用__dict__以字典类型键值对的格式返回属性
                    su = obj.__dict__
                    # 删除对象地址内存键值对操作
                    su.pop('_sa_instance_state')
                    # 以字典的格式输出每个对象的所有属性
                    print(su)
                    # 返回遍历的模型对象的属性
                return "OK"
            else:
                # 否则返回为空
                return 'Null'
        except:
            # 出现异常事务回滚
            self.session.rollback()




    # # 由本类创建的对象执行完后自动执行本函数下的代码
    # def __del__(self):
    #
    #     try:
    #         # 向数据库提交内容
    #         self.session.commit()
    #     except:
    #         # 出现异常事务回滚
    #         self.session.rollback()