Python 实现简易版ORM

ORM：对象关系映射

用来把对象模型表示的对象映射到基于S Q L 的关系模型数据库结构中去。这样，我们在具体的操作实体对象的时候，就不需要再去和复杂的 SQL 语句打交道，只需简单的操作实体对象的属性和方法 。ORM 技术是在对象和关系之间提供了一条桥梁，前台的对象型数据和数据库中的关系型的数据通过这个桥梁来相互转化 。

ORM模型的简单性简化了数据库查询过程。使用ORM查询工具，用户可以访问期望数据，而不必理解数据库的底层结构。

实现简易版ORM

因为数据库的一张表相当于创建一个类，表内的一条记录相当一个对象，那我们就要实现利用对象的点语法可以取出表内的数据。

这里利用字典k-v键值对的形式存储数据的特点实现对象的点语法取值

首先创建一个类，继承dict类，重写 __ getattr __ ，__ setattr __ 方法实现对象的点语法取值和存值。

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

    # __getattr__: 在对象获取它没有的属性和方法的时候自动触发
    def __getattr__(self, item):
        return self.get(item,'该key不存在！')

    # __setattr__: 在对象点属性设置属性值的时候自动触发
    def __setattr__(self, key, value):
        self[key] = value
        
res = Models(name='linwow',password=123)
print(res.id)
res['password'] = 456
print('用对象的形式赋值:',res.name)
print('用字典的形式赋值:',res.password)
'''
该key不存在！
用对象的形式赋值: linwow
用字典的形式赋值: 456
'''    

表中包含字段名和属性，这里利用类的方式实现 varchar 和 int 两种类型的字段

表的字段通常需要有的属性字段名，字段类型，是否是主键，默认值
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类型的字段
class Stringfield(Field):
    def __init__(self,name,column_type = 'varchar(32)',primary_key = False,default=None):
        super().__init__(name,column_type,primary_key,default)

定义一个类，可以实例化varchar类型的字段
class IntegerField(Field):
    def __init__(self,name,column_type='int',primary_key=False,default=0):
        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)
        table_name = class_attrs.get('table_name',class_name)
        primary_key = None
        # 用来存储自己定义的字段类型的属性
        mappings = {}
        # 下面的for循环需要做两件事
        # 1.将单个单个的字段整合成一个
        # 2.确定当前表当地哪个字段是主键
        for k,v in class_attrs.items():
            # 拿出所有自己定义的表的字段属性
            if isinstance(v,Field):
                # 将所有的自己定义的表的字段存入字典中
                mappings[k] = v
                # 校验一张表不能有多个主键
                if v.primary_key:
                    raise TypeError('一张表只能有一个主键')
                primary_key = v.name
        # 循环mapping拿到所有的自定义字段名
        for k in mappings.keys():
            # 将单个单个的字段删除
            class_attrs.pop(k)
        # 校验用户自定义的模型表是否指定了主键字段
        if not primary_key:
            raise TypeError('一张表必须要有一个主键')
        # 将标示表的特征信息 表名，表的主键字段，表的其他字段都塞到类的名称空间中
        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)

定义一个类利用pymysql实现对数据库的操作，提供select和execute两个对象方法来执行SQL语句，select实现查询功能，execute实现修改数据的功能。因为操作表的时候只能对一张表进行操作，所以利用类方法实现单例模式提供给外界。

import pymysql
class Mysql(object):
    _insteance = None
    def __init__(self):
        self.conn = pymysql.connect(
            host = '127.0.0.1',
            port = 3306,
            user = 'root',
            password = 'mysql',
            databases = 'mydb',
            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)
        res = self.cursor.fetchall()
        return res

    def execute(self,sql,args=None):
        try:
            self.cursor.excute(sql,args)
        except BaseException as e:
            print(e)
    # 创建单例模式
    @classmethod
    def singleton(cls):
        if not cls._insteance:
            cls._insteance = cls()
            return cls._insteance

当表被创建成对象后，这里提供两个类方法，可以通过对象点方法来对数据库进行操作。这里将类方法定义在Models中，让所有的表对象来继承Models，这样所有的表都有了这两个方法。

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

    # __getattr__: 在对象获取它没有的属性和方法的时候自动触发
    def __getattr__(self, item):
        return self.get(item,'该key不存在！')

    # __setattr__: 在对象点属性设置属性值的时候自动触发
    def __setattr__(self, key, value):
        self[key] = value

    @classmethod
    def select(cls,**kwargs):
        ms = Mysql.singleton()
        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注入，最后的%s由excute来拼接，所以这里用？来实现占位
            sql = 'select * from %s where %s=?'%(cls.table_name,k)
            sql = sql.replace('?','%s')
            res = ms.select(sql,v)
        if res:
            # 返回的值为[{},{},{}]形式，继续利用该方法实现点语法的转化
            return [cls(**r) for r in res]
    # 更新数据    
    def updata(self):
        ms = Mysql.singleton()
        fields = []
        values = []
        pr = None
        for k, v in self.mappings.items():
            if v.primary_key:
                pr = getattr(self, v.name, v.default)
            else:
                fields.append(v.name + '=?')
                values.append(getattr(self, v.name, v.default))
        sql = "update %s set %s where %s=%s" % (self.table_name, ','.join(fields), self.primary_key, pr)
        sql = sql.replace("?", '%s')
        ms.execute(sql, values)
	# 插入数据
    def save(self):
        ms = Mysql.singleton()
        fields = []
        temp = []
        values = []
        for k, v in self.mappings.items():
            if not v.primary_key:
                fields.append(v.name)
                temp.append('?')
                values.append(getattr(self, v.name, v.default))
        sql = "insert into %s(%s) values(%s)" % (self.table_name, ','.join(fields), ','.join(temp))
        sql = sql.replace('?', '%s')
        ms.execute(sql, values) 

下面我们利用自己定义的类方法实现对数据库的操作，首先要确保数据库房屋端已启动，且里面已经创建了数据库mydb，并包含teacher表

# 定义一个类，相当于创建了一张表，里面包含表结构
if __name__ == '__main__':
    class Teacher(Models):
        table_name = 'teacher'
        tid = IntegerField(name='tid', primary_key=True)
        tname = Stringfield(name='tname')
        password = Stringfield(name='password')


    obj_list = Teacher.select(tname='linwow')
    obj = obj_list[0]
    print(obj)
    obj.tname = "peter"
    obj.password = '8888'
    obj.updata()
    obj1 = Teacher(tname='wowlin', password='8888')
    obj1.save()
    '''
    {'tid': 1, 'tname': 'linwow', 'password': '8888'}
    '''

现在就完成了一个简易般的ORM。

完整代码：

import pymysql
class Mysql(object):
    _insteance = None
    def __init__(self):
        self.conn = pymysql.connect(
            host = '127.0.0.1',
            port = 3306,
            user = 'root',
            password = 'mysql',
            database = 'mydb',
            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)
        res = self.cursor.fetchall()
        return res

    def execute(self,sql,args=None):
        try:
            self.cursor.excute(sql,args)
        except BaseException as e:
            print(e)
    @classmethod
    def singleton(cls):
        if not cls._insteance:
            cls._insteance = cls()
            return cls._insteance

# 表的字段通常需要有的属性字段名，字段类型，是否是主键，默认值
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类型的字段
class Stringfield(Field):
    def __init__(self,name,column_type = 'varchar(32)',primary_key = False,default=None):
        super().__init__(name,column_type,primary_key,default)

# 定义一个类，可以实例化varchar类型的字段
class IntegerField(Field):
    def __init__(self,name,column_type='int',primary_key=False,default=0):
        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)
        table_name = class_attrs.get('table_name',class_name)
        primary_key = None
        # 用来存储自己定义的字段类型的属性
        mappings = {}
        # 下面的for循环需要做两件事
        # 1.将单个单个的字段整合成一个
        # 2.确定当前表当地哪个字段是主键
        for k,v in class_attrs.items():
            # 拿出所有自己定义的表的字段属性
            if isinstance(v,Field):
                # 将所有的自己定义的表的字段存入字典中
                mappings[k] = v
                if v.primary_key:
                    # 校验一张表不能有多个主键
                    if primary_key:
                        raise TypeError('一张表只能有一个主键')
                primary_key = v.name
        # 循环mapping拿到所有的自定义字段名
        for k in mappings.keys():
            # 将单个单个的字段删除
            class_attrs.pop(k)
        # 校验用户自定义的模型表是否指定了主键字段
        if not primary_key:
            raise TypeError('一张表必须要有一个主键')
        # 将标示表的特征信息 表名，表的主键字段，表的其他字段都塞到类的名称空间中
        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)

    # __getattr__: 在对象获取它没有的属性和方法的时候自动触发
    def __getattr__(self, item):
        return self.get(item,'该key不存在！')

    # __setattr__: 在对象点属性设置属性值的时候自动触发
    def __setattr__(self, key, value):
        self[key] = value

    @classmethod
    def select(cls,**kwargs):
        ms = Mysql.singleton()
        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注入，最后的%s由excute来拼接，所以这里用？来实现占位
            sql = 'select * from %s where %s=?'%(cls.table_name,k)
            sql = sql.replace('?','%s')
            res = ms.select(sql,v)
        if res:
            # 返回的值为[{},{},{}]形式，继续利用该方法实现点语法的转化
            return [cls(**r) for r in res]

# 定义一个类，相当于创建了一张表，里面包含表结构
if __name__ == '__main__':
    class Teacher(Models):
        table_name = 'teacher'
        tid = IntegerField(name='tid', primary_key=True)
        tname = Stringfield(name='tname')
        password = Stringfield(name='password')


    obj_list = Teacher.select(tname='linwow')
    obj = obj_list[0]
    print(obj)
    obj.tname = "peter"
    obj.password = '8888'
    obj.updata()
    obj1 = Teacher(tname='wowlin', password='8888')
    obj1.save()