1107 python自定义实现ORM

目录

• ORM
  • 模型表类
    • 创建字段类型类
    • 创建模型表类
    • 表的约束
  • 数据的操作
    • select查询语句
    • insert 插入数据
    • 修改更新数据

ORM

存: 从代码通过ORM保存到mysql中,保存的结果是json

取: 从mysql中通过ORM取出,取出来的也是json

对象关系映射,

客户端的请求到服务端,服务端接受到指令,使用ORM对数据库进行操作,而数据库的库表都是已经存在的,ORM中操作的指令无非是对应数据库的表字段,通过操作ORM的代码来实现对表,表中字段数据的操作

一开始写的时候就是对象,然后通过ORM保存到数据库中,保存的都是json数据,但想要取出来的也是对象,所以使用元类来进行封装创建

接口层 -- 数据层 -- ORM -- 数据库

			对象关系映射
	类名		  ---		表名
	
	对象	       ---       数据行
		# 对象 通过类实例化传参得来
		
	对象.属性	  ---		字段	
		# 对象.属性 在类实例化的时候添加字段的属性,触发__init__

创建一个User表,表内有字段(id,name,pwd)
# 1.表名就是类名User
# 2.字段:需要在类实例化的时候添加字段(.属性)
#     实例化会触发__init__方法
#     2.1 创建字段时具有不同的类型,创建字段类型类
#             - 字段名
#             - 字段类型
#                 int
#                 varchar
#             - 是否为主键
#             - 默认值
#             定义字段类型类,继承同一父类

模型表类

创建字段类型类

# 写字段类型类
定义字段的约束:字段的名字,字段的类型,字段是否为主键,字段有无默认值
# 字段父类
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
# int
class IntegerField(Field):
    def __init__(self,name,column_type = "int",primary_key = False,default = 0):
        super().__init__(self,name,column_type,primary_key,default)
# varchar
class StringFiled(Field):
    def __init__(self,name,column_type = "varchar(255)",primary_key = False,default =None):
        super().__init__(self,name,column_type,primary_key,default)

创建模型表类

模型表类是一张一张的表,表中有username,pwd等字段用于记录用户的数据

user表,movie表
user表中应该有 username,pwd	--- 这是字段

# 创建模型表类
#     1.创建表类的重复 --- 继承
#     2.每一张表的字段数量,名字都不一样,无法继承同一父类
#         --- 父类继承dict,dict是对象,继承dict,触发内部__init__(可接受任意数量已经类型属性)
#         dict = {key:value}    与  dict(key=value)  结果一致
#     3.字典的取存值方式有限,改为对象.属性的方式存取值
#         存, 对象.属性没有时触发    __getattr__
#         取, 对象.属性调用时触发    __setattr__

class Models(dict):
    # 1.使用字典接受所有的关键字参数
    def __init__(self,**kwargs):
        super().__init__(**kwargs)  # kwargs接受所有的关键字参数
    # 2.取值时使用getattr,self是调用者本身item是没有的属性(key)
    def __getattr__(self, item):
        return self.get(item)
    # 3.存值时使用setattr,将调用者本身的字典中的key赋值保存为value
    def __setattr__(self, key, value):
        self[key] = value



class User(Models):
    # def __init__(self,id,name,pwd):
    #     self.id = id
    #     self.name = name
    #     self.pwd = pwd
    pass

class Movie(Models):
    # def __init__(self,id,name,pwd):
    #     self.id = id
    #     self.name = name
    #     self.pwd = pwd
    pass


if __name__ == '__main__':
    d1=dict(name = 1)   # {'name': 1}
    d2 = User(name='222')   #{'name': '222'}
    print(d1)
    # print(d2.name)    # 报错
    # 取值
    print(d2['name'])   # 222
    print(d2.name)      # 222
    # 存值
    d2['name']=1231
    print(d2)       #{'name': 1231}
    d2.pwd = 1231
    print(d2)       #{'name': 1231, 'pwd': 1231}

表的约束

// 问题:让所有的表类都遵循约束,防止创建传值的失误
	- 表名
	- 必须有唯一主键
	- 表的字段
解决:	使用元类去控制类的创建,使其遵循规则
	元类控制:
        - 表名
        - 必须有唯一主键
        - 表的字段

元类的封装

# 写字段类型类

# 字段父类
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
# int
class IntegerField(Field):
    def __init__(self,name,column_type = "int",primary_key = False,default=0):
        super().__init__(name,column_type,primary_key,default)
# varchar
class StringFiled(Field):
    def __init__(self,name,column_type = "varchar(255)",primary_key = False,default=None):
        super().__init__(name,column_type,primary_key,default)


# 4.元类的创建
class MyMetaclass(type):
    # 子类的方法覆盖父类的__init方法
    # 控制了类的定义
    def __new__(cls,class_name,class_base,class_dict):
        # 接收models类的,与user类的所有
        # print(args)    # (类名,父类,类的名称空间)
        # print(kwargs)   空
        # print(class_name)
        # print(class_base)
        # print(class_dict)
        # 类的所有东西
        '''
        Models
        (<class 'dict'>,)
        {'__module__': '__main__', '__qualname__': 'Models', '__init__': <function Models.__init__ at 0x0000022B6753EBF8>, '__getattr__': <function Models.__getattr__ at 0x0000022B6753EC80>, '__setattr__': <function Models.__setattr__ at 0x0000022B6753ED08>, '__classcell__': <cell at 0x0000022B674E91C8: empty>}
        
        User
        (<class '__main__.Models'>,)
        {'__module__': '__main__', '__qualname__': 'User', 'table_name': 'user_info', 'user_id': <__main__.IntegerField object at 0x0000022B674EEDA0>, 'user_name': <__main__.StringFiled object at 0x0000022B674EEF28>, 'pwd': <__main__.StringFiled object at 0x0000022B674EE048>}

        '''
        # 1.剔除models类
        if class_name == 'Models':
            # 是models类就原路返回,什么也不做
            return type.__new__(cls, class_name, class_base, class_dict)
        # 2.设定一张表必须有一个表名
            # 从类的名称空间中获取table_name的值,如果没有就以类名作为表名
        table_name = class_dict.get('table_name',class_name)
        # print(table_name)   # user_info
        # 3.主键名默认为空
        primary_key = None
        # 4.定义一个空字典,用于存放所有的 字段 对象
        mappings = {}
            # 遍历名称空间
        for k,v in class_dict.items():
            # print(k,v)
            '''
            __module__ __main__
            __qualname__ User
            想要的是以下字段
            table_name user_info
            user_id <__main__.IntegerField object at 0x00000287AB9BED68>
            user_name <__main__.StringFiled object at 0x00000287AB9BEEF0>
            pwd <__main__.StringFiled object at 0x00000287AB9BEF28>'''
            # 过滤字段,获取想要的字段
            if isinstance(v,Field):
                # 给字典进行赋值保存字段
                mappings[k] = v
                # print(v)
                ''' v 就是每个字段对象
                <__main__.IntegerField object at 0x000001E6B993EDD8>
                <__main__.StringFiled object at 0x000001E6B993EE10>
                <__main__.StringFiled object at 0x000001E6B993EF98>'''
        # print(mappings)
                ''' 字典中字段对应的值都是对象.
                {'user_id': <__main__.IntegerField object at 0x000002056198E048>, 'user_name': <__main__.StringFiled object at 0x000002056198EEF0>, 'pwd': <__main__.StringFiled object at 0x000002056198EF28>}'''
                # 5.判断主键是否是唯一
                #     先判断字段对象中是否存在主键，对象.属性的方法获取primary_key
                if v.primary_key:
                    # 如果存在判断标记主键是否有值，有值说明循环过一次了
                    if primary_key:
                        raise TypeError('只能有一个主键')
                    # 主键标识不存在,则给primary_key赋值,防止重复
                    primary_key = v.name    # 赋值为当前具有主键的字段名

        # 6.节省资源,将mappings字典中和名称空间的重复元素删除
        for k in mappings.keys():
            class_dict.pop(k)


        # 判断是否为主键
        if not primary_key:
            raise TypeError('必须有一个主键')

        # 给类的名称空间中添加表名
        class_dict['table_name'] = table_name
        # 给类的名称空间中添加主键名
        class_dict['primary_key'] = primary_key
        # 给类的名称空间添加mappings字典,字典中是所有字段以及对象
        class_dict['mappings'] = mappings

        return type.__new__(cls,class_name,class_base,class_dict)






# 创建模型表类
#     1.创建表类的重复 --- 继承
#     2.每一张表的字段数量,名字都不一样,无法继承同一父类
#         --- 父类继承dict,dict是对象,继承dict,触发内部__init__(可接受任意数量已经类型属性)
#         dict = {key:value}    与  dict(key=value)  结果一致
#     3.字典的取存值方式有限,改为对象.属性的方式存取值
#         存, 对象.属性没有时触发    __getattr__
#         取, 对象.属性调用时触发    __setattr__


class Models(dict,metaclass=MyMetaclass):
    # 1.使用字典接受所有的关键字参数
    def __init__(self,**kwargs):
        super().__init__(**kwargs)  # kwargs接受所有的关键字参数
    # 2.取值时使用getattr,self是调用者本身item是没有的属性(key)
    def __getattr__(self, item):
        return self.get(item)
    # 3.存值时使用setattr,将调用者本身的字典中的key赋值保存为value
    def __setattr__(self, key, value):
        self[key] = value



class User(Models):
    # 自定义表名
    table_name = 'user_info'
    # 定义字段
    user_id = IntegerField(name='user_id',primary_key=True)
    user_name = StringFiled(name='user_name')
    pwd = StringFiled(name='pwd')


if __name__ == '__main__':
    s=User()
    print(s.mappings)
    '''
    {'user_id': <__main__.IntegerField object at 0x0000013DFA6BEDA0>, 'user_name': <__main__.StringFiled object at 0x0000013DFA6BEDD8>, 'pwd': <__main__.StringFiled object at 0x0000013DFA6BEF60>}'''
    print(s.table_name) # user_info
    print(s.primary_key)    # user_id

数据的操作

pymysql的使用

'''pymysql的连接使用'''
import pymysql

class MySQLClient:
    # 1.创建连接
    def __init__(self):
        # 连接客户端
        self.client = pymysql.connect(
            host = '127.0.0.1',
            port = 3306,
            user = 'root',
            password = '',
            database = 'youku',
            charset = 'utf8',
            autocommit = True   # 自动增长
        )
        # 创建游标对象并设置自动提交
        # 类似于原来的
        #     conn = pymysql.connect(user='root', password='', database='oldboy')
        #     cursor = conn.cursor()
        self.cursor = self.client.cursor(
            pymysql.cursors.DictCursor      # 输出字典格式
        )

    # 2.定义提交查询sql命令
    def my_select(self,sql,value=None):
        # 提交查询的sql指令
        self.cursor.execute(sql,value)
        # 获取查询以后得结果
        res = self.cursor.fetchall()
        return res

    # 3.封装'提交sql命令,插入或者更新'的方法
    def my_execute(self,sql,values):
        try:
            self.cursor.execute(sql,values)
        except Exception as e:
            print(e)

    # 4.关闭数据库
    def close(self):
        self.cursor.close()
        self.client.close()

select查询语句

#     查看    定义为类方法,可以类这调用
    @classmethod
    def select(cls,**kwargs):  #**kwargs接受所有的关键字参数
        # print(kwargs)   # 打散关键字参数 {'name': 'tank'}
        # 将MySQLClient实例化得到对象
        mysql = MySQLClient()
        # 定义sql语句: select * from 表名 where 条件
        # 判断传入的关键字参数是否有值
        if not kwargs:
            # 1.不存在,直接查询所有
            sql = 'select * from %s' % cls.table_name
                # 调用MySQLClient接口函数查询数据
            res = mysql.my_select(sql)

        else:
            # 2.存在,按条件查询 sql: select * from User where id=1;
            key = list(kwargs.keys())[0]    # 返回的是一个对象,需要转list
            # print(kwargs.keys())  # dict_keys(['name'])
            # print(list((kwargs.keys())))  # ['name']
            value = kwargs.get(key)
            # 防止sql注入问题,用户输入的都用?替代
            sql = 'select * from %s where %s=?' % (cls.table_name,key)
            sql = sql.replace('?','%s')     # 将?替换成%s 在execute中传参防止注入
            # 将sql语句与条件values传入查询函数方法
            res = mysql.my_select(sql,value)
            # print(res)
            # 将res列表中的字典调用cls自己本身,将其转变为对象
        return [cls(**d) for d in res]
    
运行----------------------------------

if __name__ == '__main__':
    # 查
    # 将select设置为类的绑定方法,可直接类调用
    res = User.select(user_name = 'tank')
    print(res)  # [{'user_id': 1, 'user_name': 'tank', ' pwd': '123'}]
    print(res[0])   # {'user_id': 1, 'user_name': 'tank', ' pwd': '123'}
    print(res[0].user_name)     # tank
    
    
    res = User.select()
        print(res)      # [{'user_id': 1, 'user_name': 'tank', ' pwd': '123'}, {'user_id': 2, 'user_name': 'nick', ' pwd': '321'}]

insert 插入数据

 # 插入数据
    def orm_insert(self):
        mysql = MySQLClient()
        # sql = 'insert into 表名(字段名) values (值1,值2);

        # 存储字段名
        keys = []
        # 存储字段对应的值,用于传参
        values = []
        # 存储问号,有几个?就存储几个
        args = []
        # print(self.mappings)
        '''{'user_id': <__main__.IntegerField object at 0x000001789E2600F0>, 'user_name': <__main__.StringFiled object at 0x000001789E2602E8>, 'pwd': <__main__.StringFiled object at 0x000001789E260320>}'''
        for k,v in self.mappings.items():
            # print(1,k,v)
            '''1 user_id    <__main__.IntegerField object at 0x000001B9D25EE128>
             1 user_name    <__main__.StringFiled object at 0x000001B9D25EE320>
             1 pwd <__main__.StringFiled object at 0x000001ECAE8DF320>'''
            # 过滤掉主键,主键是自增的所以不会传值
            # print(v.primary_key)    # True  False,v是user_id或user_name的对象,是否有.属性的primarykey方法
            if not v.primary_key:
                # print(v.name)   # user_name     pwd
                # 去除掉主键之后,获取其他的
                keys.append(v.name)     # 字段的属性
                # print(v.column_type)    # column_type
                # print(v.name)    # user_name    print(k)    # user_name   k=v.name
                # print(keys)     # ['user_name', 'pwd']   将所有的key保存至列表中
                # 存表中除了主键以外的字段值,若值没有,则使用默认值
                values.append(
                    getattr(self,v.name,v.default)  # 通过反射获得self中的name对应的值
                )   # self是他传进来的关键字参数,被打散为字典,也可按key取值

                # print(v)    # <__main__.StringFiled object at 0x000002B56E39E358>
                # print(v.name,v.default)      # user_name None
                # print(self)  #  {'user_name': '小明', 'pwd': 123}
                # print(self.get(v.name))     # 小明
                # print(getattr(self,v.name))     # 小明
                # print(values)               # ['小明']
                # 存放?号的,有几个字段,添加几个?
                args.append('?')
                # print(args)     # ['?', '?']

        # 编写sql语句指令
        sql = 'insert into %s(%s) values (%s)' % (
            self.table_name,
            ','.join(keys),     # ['?', '?']变为 user_name,pwd
            ','.join(args)
        )
        # 将?替换
        sql = sql.replace('?','%s')
        # 传值到上传函数
        mysql.my_execute(sql,values)
        # print(keys)

----------------------------------------------------------
if __name__ == '__main__':
    # 增
    obj = User(user_name='nihao',pwd=123)
    obj.orm_insert()
    res = User.select()
    print(res)
    '''
[{'user_id': 1, 'user_name': 'tank', 'pwd': '123'}, {'user_id': 2, 'user_name': 'nick', 'pwd': '321'}, {'user_id': 3, 'user_name': 'nihao', 'pwd': '123'}, {'user_id': 4, 'user_name': 'nihao', 'pwd': '123'}]'''

修改更新数据

 # 更新方法数据(修改数据)固定用主键当做查询方法
    def orm_update(self):
        print(0,self)       # 0 {'user_id': 3, 'user_name': '哈哈哈', 'pwd': '123'}
        '''sql = update 表名 set k1=v1, k2=v2 where id=主键值'''
        myslq = MySQLClient()
        # 字段名
        keys = []
        # 字段值
        values = []
        # 主键内容 id=主键名
        primary_key = None  # 主键名 = 主键序列号   id = 12

        for k,v in self.mappings.items():
            # print(0,k,v)
            # 0 user_id <__main__.IntegerField object at 0x000001A110BCF1D0>
            # 0 user_name <__main__.StringFiled object at 0x000001A110BCF400>
            # 0 pwd <__main__.StringFiled object at 0x000001A110BCF438>

            # 判断有无主键的存在,得到有主键的字段,便于where条件查询
            if v.primary_key:
                primary_key = v.name + '= %s' % getattr(self,v.name)
                # print(1,primary_key)      # 1 user_id= 3
            else:
                # 剩下的没有主键的字段都是想要修改的字段与新值
                keys.append(v.name + '=?')
                values.append(
                    getattr(self,v.name)  # 将用户传入的参数利用getattr方法进行获得值
                )
                # print(2,self)
                # 2 {'user_id': 3, 'user_name': '哈哈哈', 'pwd': '123'}
                # 2 {'user_id': 3, 'user_name': '哈哈哈', 'pwd': '123'}
                # print(3,getattr(self,v.name))
                #     3 哈哈哈
                #     3 123
        # 语句# sql: update table set k1=?, k2=? where id=pk; #
        sql = 'update %s set %s where %s' % (
            self.table_name,
            ','.join(keys),
            primary_key
        )
        # print(4,sql)
        # 4 update user_info set user_name=?,pwd=? where user_id= 3

        # 替换其中的?号
        sql = sql.replace('?','%s')
        myslq.my_execute(sql,values)
        
        
---------------------------------------------------------
if __name__ == '__main__':
    # 修改更新
    user_obj = User.select(user_name='hhh')[0]
    # print(user_obj) # {'user_id': 3, 'user_name': 'nihao', 'pwd': '123'}
    user_obj.user_name = '哈哈哈'
    # 对象.属性获得字段,将字段赋值为'哈哈哈',调用update函数将自身传入进去,然后根据sql语句更新
    user_obj.orm_update()