前言

关于ORM

ORM是指对象关系映射（Object Relational Mapping，简称ORM），从全称上可以看出这是处理【对象】和【关系型数据库】之间的映射的技术。 我们先来看看一个数据表：

CREATE TABLE users (  
    id INT AUTO_INCREMENT PRIMARY KEY,  
    username VARCHAR(50) NOT NULL,  
    email VARCHAR(100) NOT NULL,  
    birthdate DATE,  
    is_active BOOLEAN DEFAULT TRUE  
);

当我们进行查询或者插入的时候，需要这么写：

# 查询
SELECT id, username FROM users;
# 插入
INSERT INTO users (id, username) VALUES (1,"Tom");

可以发现，如果要进行数据库操作，需要拼接许多sql语句，这对于代码的维护和更新来说，将会增加许多工作量。 如果可以有一个办法，把面向对象和关系型数据结合起来，那将会方便很多。 比如，上述的操作，可以变成类似这样：

class User:
    id = INT(auto_increment = True, primary_key = True)
    username = VARCHAR(50)
    email =  VARCHAR(100)
    

# 创建数据表
create(User)
# 或者：
User.create()

# 查询
result = User.select().where(id = 1)
# 或者:
result = select(User).where(id = 1)

# 插入
User.insert(id = 1, name = "Tom")
# 或者
insert(User(id = 1, name = "Tom"))

以上是举个例子，实际的ORM类库不一定是这样的风格。 主要是表达出ORM的观点：将对象和关系型数据库进行映射，对象的属性就是数据库的字段，对象的方法就是数据库的操作。 通过这样的映射，可以省去拼接sql语句，也可以进行更多复杂的操作，例如数据校验等等。

* ORM的两种风格

详细介绍元类和ORM之前，先聊一下ORM的两种模式：active record 和 data mapper。 1.Active Record模式： 把数据模型和数据持久化结合，每个描述数据表的模型都包含访问数据库的方法，可以直接操作数据库。例如上面的：

User.create()
result = User.select().where(id = 1)

在python中，Django的ORM，Peewee等就是使用active record模式。 2. Data Mapper模式： 这个模式把数据模型和数据持久化分开，由一个独立的数据映射来处理数据持久化，数据模型只是负责业务逻辑。 例如上面的:

create(User)
result = select(User).where(id = 1)

SQLAlchemy就是使用data mapper模式。

这里不去讨论两种的优劣，只是简单介绍有这两种模式。后面的代码将通过active record来实现ORM.

元类的ORM的关系

在介绍了元类和ORM之后，二者到底有什么关系？ 我们看这样一个例子： 在一个user表里面，写入id =1,username="Tom";id = 2, username = "Jack"。 如果创建一个函数:

def insert_user(id:int,username:str):
    sql = f'INSERT INTO user (id,username) VALUES ({id},{username})'

这将和拼接sql是没有差别的，并不是orm。 实际上我们是不知道创建表的时候，会有什么字段，这些字段都是使用者自己创建的。 因此，我们要有这样的映射： 【类】——>【数据表】 【类属性】——>【数据表字段】 【对象】——>【数据记录】 【对象属性值】——>【数据表字段值】

我们希望使用的方式类似这样：

Class User:
    # 类属性映射到数据表
    id = IntegerField('id')
    username = VarcharField('username')
    
# 实例化一条数据记录
user1 = User(id = 1, username = 'Tom')
# insert
user1.insert()

user2 = User(id = 2,username = 'Jack')
user2.insert()

可以看到，在创建User类的时候，需要进行字段映射，因此，这里就是使用元类的原因：【拦截和修改类的创建】，让使用者在定义类的时候，完成对数据表的定义；在实例化一个类的时候，完成一条数据记录的定义。

使用元类实现ORM

先完成字段类型的定义：

class Field:  
    def __init__(self, name):  
        self.name = name  
  
  
class IntegerField(Field):  
    def __init__(self, name):  
        super().__init__(name)  
        self.type = 'int'  
  
  
class VarcharField(Field):  
    def __init__(self, name):  
        super().__init__(name)  
        self.type = 'varchar(100)'

元类的定义：

class MetaModel(type):  
    def __new__(cls, name, bases, attrs):
        # 排除Model类
        if name == 'Model':  
            return type.__new__(cls, name, bases, attrs)  
        
        # 将类属性隔离，避免后续实例化被覆盖。 类定义了id=IntegerField()，实例化id = 1会因为同名被覆盖
        mapper = {}  
        for k, v in attrs.items():  
            if isinstance(v, Field):  
                mapper[k] = v  
  
        for k in mapper:  
            attrs.pop(k)  

        attrs['__mapper__'] = mapper  
        if '__table__' not in attrs:  
            attrs['__table__'] = name  

        return type.__new__(cls, name, bases, attrs)

Model类的定义:

class Model(metaclass=MetaModel):  
    # 实例化设置具体值
    def __init__(self, **kwargs):  
        for k, v in kwargs.items():  
            self.__setattr__(k, v)  
  
    def insert(self):  
        column_li = []  
        val_li = []  
        # 读取元类设置好的__mapper__
        for k, v in self.__mapper__.items():  
            val = getattr(self, k, None)  
            if val is not None:  
                # 注意这个v.name，这是Field字段的name，实际数据表里面的字段名
                column_li.append(v.name)  
                val_li.append(f'"{val}"')  

        print(column_li)  
        print(val_li)  

        sql = f'INSERT INTO {self.__table__} ({",".join(column_li)}) VALUES ({",".join(val_li)})'  

        print(sql)
        
    @classmethod  
    def create(cls):  
        cloumn_li = []  
        for k, v in cls.__mapper__.items():  
            cloumn_li.append(f'{v.name} {v.type}')  
        sql = f'CREATE {cls.__table__} {",".join(cloumn_li)}'  

        print(sql)

调用情况：

class User(Model):  
    __table__ = 'user'
    id = IntegerField('id')  
    username = VarcharField('username')  
  
User.create()
user = User(id=1, username='tom')  
user.insert()

输出：
CREATE user id int,username varchar(100)
['id']
['"1"']
INSERT INTO user (id) VALUES ("1")

元类主要做了几件事： 1.收集类属性，判断类属性是否是属于File()，也就是是否是数据表字段。将这些字段存入__mapper__，【避免实例化被具体数值覆盖】。 2.表名设置。通过对类属性的检查，设置表名。 因此，如果需要其他额外属性的设置，也可以在元类定义加入。 这就是核心的把类、对象和数据表进行映射。还可以加上其他操作方法、增加不同的数据库语法、字段检查等等。

总结

使用ORM可以方便的进行关系型数据库库操作，减少开发负担。要实现ORM的重点，就是如何把类和实例与关系型数据库进行映射。 python的元类，可以在拦截和修改类的创建，因此可以通过元类，在类的定义时，进行映射。 回到最初的问题：ORM一定要用元类来实现吗？ 通过上述的内容可以得知，只要能够完成映射，就不一定需要用元类。 后续会展示不使用元类实现的ORM。