orm终极大爆炸

orm终极

• 甩一个代码给你

# 创建字段

class Field:

    def __init__(self, name, column_type, primary_key, default):
        self.name = name
        self.column_type = column_type
        self.primary_key = primary_key
        self.default = default


# varchar 字段类型
class StingField(Field):
    def __init__(self, name, column_type='varchar(64)', primary_key=False, default=None):
        super().__init__(name, column_type, primary_key, default)


# int 字段类型
class IntegerField(Field):
    def __init__(self, name, column_type='int', primary_key=False, default=0):
        super().__init__(name, column_type, primary_key, default)


from day38.mysql_control import MySQL

class OrmMetaClass(type):
    def __new__(cls, class_name, class_bases, class_attr):   # 将models的类名， 基类，以及类的名称空间传给自定义的元类
        # 1、过滤掉除了我想控制的类以外的其他的类 此时是过滤掉models
        if class_name == 'Models':

            # 将models类的类名，基类，类的名称空间原路返回
            return type.__new__(cls, class_name, class_bases, class_attr)

        # 2、获取表名，若有自定义表名则用自定义表名，若没有则默认用类名做表名
        table_name = class_attr.get('table_name', class_name)

        # 先将主键值设为None
        primary_key = None

        # 想把字段名以及字段对象单独存放在一个字典中, 后面在把这个字典添加到类的 名称空间中去
        mappings = {}

        # 3、保证一张表只能有唯一的一个主键
        # 循环遍历获得字段 字段对象
        for k, v in class_attr.items():
            # print(k, v)
            if isinstance(v, Field):

                # 4、将所有的 字段名 以及 字段对象 添加到一个独立的字典中
                mappings[k] = v
        # print(mappings)  查看mappings


                # 判断字段对象是否有主键，且主键是否唯一
                if v.primary_key:

                    # 若第二次进来，primary_key 有值，证明已经有一个主键了，抛出一个异常
                    if primary_key:
                        raise TypeError('一张表只能有一个主键')

                    # 确定主键名
                    primary_key = v.name


        # 5、过滤掉类名称空间中与独立字典中重复的字段 已经字段属性
        for key in mappings.keys():
            class_attr.pop(key)


        if not primary_key:
            raise TypeError('必须要有一个主键')

        # 6、再将表名 主键 独立的字典 添加到类的名称空间中去
        class_attr['table_name'] = table_name
        class_attr['primary_key'] = primary_key
        class_attr['mappings'] = mappings

        # 7、返回给models类
        return type.__new__(cls, class_name, class_bases, class_attr)



class Models(dict, metaclass=OrmMetaClass):

    # 对象.属性 没有时 触发
    def __getattr__(self, item):

        return self.get(item)   # 将属性返回出去  比如将name返回出去

    # 对象.属性 = 属性值 时触发
    def __setattr__(self, key, value):

        # 给字典添加键值对的方式
        self[key] = value


    # 查询数据
    @classmethod
    def select_data(cls, **kwargs):   # **的作用是将传过来的打散
        mysql_obj = MySQL()

        filed_value = None
        # 若kwargs 为false代表没有查询条件
        if not kwargs:
            # 1、查所有
            # sql = 'select * from 表名'
            sql = f'select * from {cls.table_name}'

        else:
            # 获取字段名
            filed_name = list(kwargs.keys())[0]

            # 获取字段值
            filed_value = kwargs.get(filed_name)

            # 2、根据条件查询
            # select * from 表名 where 字段名 = 字段值；
            sql = f'select * from {cls.table_name} where {filed_name}=?'
            sql = sql.replace('?', '%s')
            # print(filed_value)

        res = mysql_obj.select(sql, filed_value)

        return [cls(**i) for i in res]  # ---> [{}, {}] --->[onj, obj]


    # 插入数据
    def insert_data(self):   # ---> user_obj
        mysql_obj = MySQL()

        # sql :insert into 表名(字段名1， 字段名2) values(字段值1， 字段值2);
        # 1、表名 ----> self.table_name
        # 2、字段名与字段值 ---> mappings

        # 存放字段名的列表
        filed_names = []  # [字段名， 字段名]

        # 存放字段值的列表
        filed_values = []  # [字段值， 字段值]

        # 设置一个替换值的列表
        replace_list = [] # [?, ?]

        for k, v in self.mappings.items():

            # 获取字段名，追加到表中
            filed_names.append(v.name)

            # 获取字段值，追加到列表中
            filed_values.append(
                # 反射：根据字符串操作对象中的属性或方法
                self.get(v.name, v.default)
                # getattr(self, v.name, v.default)  这个也可以，只是getattr 返回的是__getattr__返回的值。如果没有返回None
            )

            replace_list.append('?')

        # sql = f'-- insert into {self.table_name}({",".join(filed_names)}) values({",".join(replace_list)})'
        sql = 'insert into %s(%s) values(%s)' % (
            self.table_name, ",".join(filed_names), ",".join(replace_list)
        )
        sql = sql.replace('?', '%s')

        mysql_obj.execute(sql, filed_values)


    # 更新数据
    def update_data(self):
        mysql_obj = MySQL()

        # sql :update 表名 set 字段名=字段名 where pk=主键值;

        # 主键值
        pk = None

        # 存放字段名的列表
        filed_name = []

        # 存放字段值的列表
        filed_values = []

        for k, v in self.mappings.items():
            # 判断mappings中那一个字段是主键
            if v.primary_key:
                # 获取主键的值
                pk = getattr(self, v.name)

            else:
                # 添加字段名
                filed_name.append(v.name + '=?')

                # 添加字段值
                filed_values.append(
                    getattr(self, v.name)
                )

        #sql: update User set 字段名=字段值， 字段名=字段值
        # sql: update User set username=?, password=? where pk=1;

        sql = 'update %s set %s where %s=%s' %(
            self.table_name,
            ','.join(filed_name),
            self.primary_key,
            pk
        )

        sql = sql.replace('?', '%s')

        mysql_obj.execute(sql, filed_values)



class User(Models):

    id = IntegerField(name='id', primary_key=True)
    username = StingField(name='username')
    password = StingField(name='password')


if __name__ == '__main__':
    # user_obj = User(name='tank')
    # print(user_obj)
    # print(user_obj.name)

    # dict = {'name': 'tank'}
    # print(type(dict.keys()))
    # print(list(dict.keys()))

    # user_obj = User(username='JASON_DSB', password='123')
    # user_obj.insert_data()
    # 获取Jason对象
    # user_obj = User.select_data(username='大didi')[0]
    # # 修改对象中属性的值，然后再调用update方法更新到数据库中
    # user_obj.username = '大jiji'
    #
    # user_obj.update_data()
    user_obj = User.select_data()
    print(user_obj)

• mysql_pool.py

自定义一个mysql_pool.py文件
# pip install DBUtils
from DBUtils.PooledDB import PooledDB
import pymysql
'''
数据库连接池
'''
POOL = PooledDB(
    creator=pymysql,  # 使用链接数据库的模块
    maxconnections=6,  # 连接池允许的最大连接数，0和None表示不限制连接数
    mincached=2,  # 初始化时，链接池中至少创建的空闲的链接，0表示不创建
    maxcached=5,  # 链接池中最多闲置的链接，0和None不限制
    maxshared=3,
    # 链接池中最多共享的链接数量，0和None表示全部共享。
    # PS: 无用，因为pymysql和MySQLdb等模块的 threadsafety都为1，所有值无论设置为多少，_maxcached永远为0，所以永远是所有链接都共享。
    blocking=True,  # 连接池中如果没有可用连接后，是否阻塞等待。True，等待；False，不等待然后报错
    maxusage=None,  # 一个链接最多被重复使用的次数，None表示无限制
    setsession=[],  # 开始会话前执行的命令列表。如：["set datestyle to ...", "set time zone ..."]
    ping=0,
    # ping MySQL服务端，检查是否服务可用。# 如：0 = None = never, 1 = default = whenever it is requested, 2 = when a cursor is created, 4 = when a query is executed, 7 = always
    host='127.0.0.1',
    port=3306,
    user='root',
    password='123456', #你们自己的密码是多少就写多少
    database='orm_demo',  # 换成你们自己想要连接的数据库
    charset='utf8',
    autocommit=True
)

• mysql_control.py

自定义一个mysql_control.py
import pymysql
from mysql_pool import POOL


# MySQL连接类
class MySQL:

    __instance = None

    # 单例模式
    @classmethod
    def singleton(cls):
        if not cls.__instance:
            cls.__instance = cls()

        return cls.__instance

    # 实例化MySQL类时，获取数据库链接对象，获取游标对象
    def __init__(self):
        # self.mysql_client = pymysql.connect()
        self.mysql_client = POOL.connection()

        self.cursor = self.mysql_client.cursor(
            pymysql.cursors.DictCursor
        )

    # 自定义查询方法
    def select(self, sql, args=None):
        # 1、先提交查询sql语句
        # select * from table;
        # select * from table where id=%s;
        self.cursor.execute(sql, args)

        # 2、获取返回的查询结果
        # res ---> [{}, {}]
        res = self.cursor.fetchall()
        return res

    # 自定义提交sql语句方法，比如: insert、update
    def execute(self, sql, args):
        # 1、提交sql语句
        # insert into table(字段) values(%s);
        try:
            self.cursor.execute(sql, args)

        except Exception as e:
            print(e)

    def close(self):
        # 先关闭游标
        self.cursor.close()
        # 再关闭数据库连接
        self.mysql_client.close()