前言
在上一篇文章中https://www.jianshu.com/p/c41373f16064, 介绍了python元类的概念以及几个应用的例子，这次来介绍一下ORM以及解答之前的问题【为什么搜索元类应用，总是出现ORM】
关于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模式。
- 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。
