u库前戏

u库

ORM:对象关系映射
类        》》》  数据库的一张表
对象      》》》  表的一条记录
对象点属性 》》》 记录某一个字段对应的值
'''
对象就是一个容器，里面装着属性和方法，而类就是盛放对象的一堆属性和方法，对象点来获取属性和方法。表就是装着一堆记录数据，通过对象点属性去获取某一个字段对应的值
'''
'''
一个字段有字段名，字段类型，字段是否是主键，字段的默认值，通过类返回的对象去点这些属性
'''
the first step:
先将表中的字段的各个属性字段名，字段类型，字段是否是主键，字段的默认值存放在类中，对象可以通过点来获取到某一个字段对应的值

the second step:
针对字段类型来写类，字段类型就有字符串类型（varchar,char），int
先写一个可以定义varchar类型字段的类，再写定义一个整型字段的类

the thrid step:
定义三个类User,Notice,Movie,这三个类不能写__init__,用父类来写一个__init__,在实列化对象的时候，不管传多少个关键字实参我都可以满足，不同的对象传入的关键字实参不等，但都可以实例化被同一个父类实例化出来，能想到的是字典的实例化d=dict(),父类中就继承这个字典这个类就可以实现

the fourth step:
d=dict(name='json',password='123')
name='json',password='123'这些都是对象属性对应的值，并不是对象的属性，所以d.name就是报错，（dict.get('name')这是字典的取值方式）
'''
有双杆的都表示自动触发
'''
__getattr__:在对象获取它没有的属性和方法的时候自动触发
__setattr__:在对象点属性设置属性值的时候自动触发
getattr():根据字符串获取对象对应属性和方法
所以要在父类中加入def __getattr__和__setattr__来获取数据和修改数据

the fifth step:
一张表要有表名，一个主键，好多字段，说明这个类里面有表名，有字段，有主键，元类就是用来创建类，而现在的类就是对应的一张表，所以创建类就是创建表，在类创建之前就哟啊拦截这个类，将这些塞给这个类，才算是一张表
user,notice,movie三个类是就是三个表，三个表都是继承models,所以models中继承元类。
'''
当类名为models时，就不需要拦截，原本该怎么创建就怎么创建，因为models并不是一张表，只是在创表的那个类继承models的方法，也就是用到字典类传参的那个功能而定义的类，之所以要models继承这个元类是因为是所有表类继承的父类，为了图方便就直接继承
'''
'''
元类中的__new__就是造一个名称空间，为了拦截的是创建表格的创建，创建的空间需要类名和基类和类体。
'''
'''
创建user这个类的时候，右键运行，会先跳到元类中，而user类中的代码也就是元类中class_attrs中的属性代码，所以元类中的class_attrs中已包含user中的代码还有自己为class_attrs这个字典自加的代码
'''

orm.py

from mysql_singlenton import Mysql

class Field(object):
    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,默认主键为False,默认值为None
class StringField(Field):
    def __init__(self, name, column_type='varchar(32)', primary_key=False, default=None):
        # 调用父类的__init__
        super().__init__(name, column_type, primary_key, default)

# 定义一个整型字段的类
class IntegerField(Field):
    def __init__(self, name, column_type='int', primary_key=False, default=None):
        super().__init__(name, column_type, primary_key, default)

class MyMetaclass(type):
    def __new__(cls, class_name, class_bases, class_attrs):
        # 我们定义的元类是用来拦截模型表的创建过程，
        # 而models并不是一张模型表，所以不需要它的创建过程
        if class_name == 'Models':
            return type.__new__(cls, class_name, class_bases, class_attrs)
        # 获取类体代码中的属性，如果没有表名，就用类名来作为表名
        # 注意：get获取key,返回vaule，如果没有就返回None,如果写了第二个参数就返回第二个参数
        table_name = class_attrs.get('table_name', class_name)
        primary_key = None
        # 只要是表的字段的，我都放在字典中去，就不需要一个个去拿，直接拿到一个字典就有所有的字段了
        mappings = {}
        for k, v in class_attrs.items():
            # 拿出所有自己定义的表属性，过滤掉那个table_name
            # v是对象，Field是类，判断这个对象是否属于这个类
            if isinstance(v, Field):
                mappings[k] = v
                if v.primary_key:
                    # 以防创建两个主键
                    if primary_key:
                        raise TypeError('一张表只能有一个主键')
                    primary_key = k
        for k in mappings.keys():
            # 将单个的字段删除，for循环mappings拿到所有的字段
            class_attrs.pop(k)
        # 创建一个表有且要有一个主键，如果没有这个主键，那么就要报错
        if not primary_key:
            raise TypeError('一张表必须要有主键')

        # 以下是将所有在名称空间中的属性数据都保存起来，调用父类的__new__进行保存到名称空间中
        class_attrs['table_name'] = table_name
        class_attrs['primary_key'] = primary_key
        class_attrs['mappings'] = mappings
        return type.__new__(cls, class_name, class_bases, class_attrs)

class Models(dict, metaclass= MyMetaclass):
    def __init__(self, **kwargs):
        super().__init__(**kwargs)

    # self是字典的对象，
    def __getattr__(self, item):
        self.get(item, '没有该键')  # 在没有这个item这个值的时候才会触发后面的‘没有该键’

    def __setattr__(self, key, value):
        try:
            self[key] = value
        except BaseException as e:
            print(e)

    @classmethod
    def select(cls, **kwargs):
        # 调用Mysql的查询方法
        ms = Mysql.singleton()
        # select * from %s
        # 当没有参数传入，代表查询所有的数据
        if not kwargs:
            sql = 'select * from %s' % cls.table_name
            res = ms.select(sql)
        else:
            k = list(kwargs.keys())[0]
            v = kwargs.get(k)
            sql = "select * from %s where %s=?" % (cls.table_name, k)
            sql = sql.replace('?', '%s')
            res = ms.select(sql, v)
        if res:
            print(res)
            return [cls(**r) for r in res]
        # select * from %s where %s=%s

if __name__ == '__main__':
    class User(Models):
        table_name = 'userinfo'
        id = IntegerField(name='id', primary_key=True)
        name = StringField(name='name')

    rs = User.select(password='123')
    print(rs)

    class Notice(Models):
        pass

    class Movie(Models):
        pass

mysql_singlenton.py

import pymysql

class Mysql(object):
    _instance = None
    def __init__(self):
        self.conn = pymysql.connect(
            host='127.0.0.1',
            port=3306,
            user='root',
            password='123',
            database='day41',
            charset='utf8',
            autocommit=True
        )
        self.cursor = self.conn.cursor(pymysql.cursors.DictCursor)

    def close_db(self):
        self.cursor.close()
        self.conn.close()

    def select(self,sql,args=None):

        self.cursor.execute(sql,args)
        # 注意一点：fetchall拿到的数据结构是一个列表套字典[{},{},{}]
        res = self.cursor.fetchall()
        return res

    def execute(self, sql,args):
        #insert into user(name,password) values('jason','123')
        #update user set name='jason',password='456' where id=1
        try:
            self.cursor.execute(sql,args)
        except BaseException as e:
            print(e)

    @classmethod
    def singleton(cls):
        if not cls._instance:
            cls._instance = cls()
        return cls._instance