SQLAlchemy 提供了一种很好的与数据库交互的“Pythonic”方式。因此，与其处理传统 SQL（如 MySQL、PostgreSQL 或 Oracle）的特定方言之间的差异，不如利用 SQLAlchemy 的 Pythonic 框架来简化工作流程并更有效地查询数据。

本文有 4个部分。

1、什么是 ORM，它有什么作用？

2、安装相关模块及docker运行MySQL

3、连接数据库

4、使用对象关系使用CRUD

5、验证数据

6、结论

什么是 ORM，它有什么作用？

ORM 代表对象关系映射。它是一种在 Python 代码和 SQL 表之间充当某种翻译器的技术。它基本上允许你将数据库表中的记录用作 Python 中的 Python 对象。将其视为将你的表格转换为列表，其中每个条目都是代表一行的 Python 对象。

使用 ORM 有很多优点：

• 对数据库无影响：你的代码即使在迁移数据库时也能正常工作
• 不易出错：没有语法错误，因为 SQL 已生成
• 通过模型的额外功能（例如验证）
• 整齐地组织项目模型：通过在项目中整齐地组织所有模型

安装相关模块及docker运行MySQL

• docker运行MySQL

# Create a volume to persist the data.
$ docker volume create mysql8-data

# Create the container for MySQL.
$ docker run --name mysql8 -d -e MYSQL_ROOT_PASSWORD=root -p 13306:3306 -v mysql8-data:/var/lib/mysql mysql:8

# Connect to the local MySQL server in Docker.
$ docker exec -it mysql8 mysql -u root -proot

mysql> SELECT VERSION();
+-----------+
| VERSION() |
+-----------+
| 8.0.27    |
+-----------+
1 row in set (0.00 sec)

• 安装相关模块

需要安装的包：

• SQLAlchemy — 将用于与数据库交互的主要包。
• SQLAlchemy-Utils — 为 SQLAlchemy 提供各种实用函数。
• sqlacodegen — 一种读取现有数据库结构并生成适当的 SQLAlchemy 模型代码的工具。
• PyMySQL — SQLAlchemy 使用它来连接到 MySQL 数据库并与之交互，如果你想了解PyMySQL请看我这篇文章：
• cryptography — SQLAlchemy 使用它进行身份验证。

pip install SQLAlchemy
pip install SQLAlchemy-Utils
pip install sqlacodegen
pip install cryptography
pip install pyMySQL

连接数据库

SQLAlchemy 为我们提供了一些用于管理数据库连接的选项，但它们都是从引擎的概念开始的。“引擎”是代表数据库的 Python 对象。引擎是通过传入目标数据库的连接信息预先创建的。

创建引擎后，我们可以随时通过与引擎对象交互来快速使用我们的数据库。将 SQL 语句直接传递给引擎让 SQLAlchemy 处理打开新连接、执行并立即关闭连接。对于维持大量数据传输的复杂 Web 应用程序，最好通过会话持久连接数据库。我们将在下一篇文章中讨论。

创建引擎的语法非常简单。create_engine()需要一个位置参数，它是一个字符串，表示连接到数据库的连接信息：

"""Create database connection."""
from sqlalchemy import create_engine
engine = create_engine(
    "mysql+pymysql://user:password@host:3306/database",
)

将 URI 分解成各个部分如下所示：

[DB_TYPE]+[DB_CONNECTOR]://[USERNAME]:[PASSWORD]@[HOST]:[PORT]/[DB_NAME]

[DB_TYPE]：指定我们要连接的数据库的种类（方言）。SQLAlchemy 可以与所有主流类型的关系数据库进行交互。根据你要连接的数据库，替换[DB_TYPE]为匹配的方言：

• MySQL：mysql
• PostgreSQL：postgresql
• SQLite：sqlite
• oracle：oracle
• Microsoft SQL：mssql

[DB_CONNECTOR]：为了管理你的数据库连接，SQLAlchemy 利用你选择使用的任何 Python 数据库连接库。如果你不确定这意味着什么，这里是我为每种方言推荐的库：

• MySQL : pymysql
• PostgreSQL：psycopg2，pg8000
• SQLite：不需要第三方库
• Oracle：cx_oracle
• Microsoft SQL: pymssql , pyodbc

后面的变量看起来应该都很熟悉；这些是指你的目标数据库的 URL、数据库用户、该用户的密码等。

使用对象关系使用CRUD

在这一部分中，我们将关注基础知识并使用 SQLAlchemy ORM 来：

1. 创建一个表
2. 插入一条记录
3. 选择一条记录
4. 删除一条记录
5. 更新记录

• 创建表

在这一部分中，我们将为表定义模型。在下面的部分中，我们以 Student 类的形式创建一个 Python 对象，然后使用 SQLAlchemy 实际创建表

import sqlalchemy as sa
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column,String,Integer

engine = sa.create_engine("mysql+pymysql://root:root@127.0.0.1/test",encoding="utf-8",echo=True,max_overflow=5)
# 连接mysql数据库，echo为是否打印结果

Base = declarative_base()  # 生成orm基类


class User(Base):  # 继承生成的orm基类
    __tablename__ = "user"  # 表名
    id = Column(Integer, primary_key=True)  # 设置主键
    user_name = Column(String(32))
    user_password = Column(String(64))


class Admin(Base):
    __tablename__ = "admin"
    id = Column(Integer, primary_key=True)
    username = Column(String(32))
    password = Column(String(64))


Base.metadata.create_all(engine)  # 创建表结构

就这么简单！user跟admin 类描述了我们的表：表的名称、模式和每列的配置。

接下来我们导入 declarative_base。这是一个返回所有表模型都必须继承的基类的函数。将其视为为所有模型提供工具箱。然后我们使用 Base“工具箱”来create_all使用我们的数据库连接来创建表。

• 使用ORM插入记录

在这一部分中，我们将使用上面定义的模型在新创建的表中插入一些新记录。

import sqlalchemy as sa
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column,String,Integer

engine = sa.create_engine("mysql+pymysql://root:root@127.0.0.1/test",encoding="utf-8",echo=True,max_overflow=5)
# 连接mysql数据库，echo为是否打印结果

Base = declarative_base()  # 生成orm基类


class User(Base):  # 继承生成的orm基类
    __tablename__ = "user"  # 表名
    id = Column(Integer, primary_key=True)  # 设置主键
    user_name = Column(String(32))
    user_password = Column(String(64))


class Admin(Base):
    __tablename__ = "admin"
    id = Column(Integer, primary_key=True)
    username = Column(String(32))
    password = Column(String(64))


newUser = User(user_name="jack", user_password="123456")

Session = sa.orm.sessionmaker(engine)
with Session() as session:
    session.add(newUser)
    session.commit()

我们通过创建之前的 Student 类的新实例来创建一个新学生。然后我们使用导入的 sessionmaker 将其添加并提交到我们的表中。这不仅非常容易；请注意，我们没有编写一行 SQL！

• 选择一条记录

选择数据比插入数据更容易

import sqlalchemy as sa
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column,String,Integer
from sqlalchemy import select  # 导入select方法

engine = sa.create_engine("mysql+pymysql://root:root@127.0.0.1/test",encoding="utf-8",echo=True,max_overflow=5)
# 连接mysql数据库，echo为是否打印结果

Base = declarative_base()  # 生成orm基类


class User(Base):  # 继承生成的orm基类
    __tablename__ = "user"  # 表名
    id = Column(Integer, primary_key=True)  # 设置主键
    user_name = Column(String(32))
    user_password = Column(String(64))


class Admin(Base):
    __tablename__ = "admin"
    id = Column(Integer, primary_key=True)
    username = Column(String(32))
    password = Column(String(64))


stmt = select(User).limit(1)  # 这里我们使用了select方法
Session = sa.orm.sessionmaker(engine)
with Session() as session:
    for row in session.execute(stmt):
        print(f"User {row.User.user_name} Password is {row.User.user_password} ")

• 删除一条记录

删除数据非常类似于选择

import sqlalchemy as sa
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column,String,Integer
from sqlalchemy import delete

engine = sa.create_engine("mysql+pymysql://root:root@127.0.0.1/test",encoding="utf-8",echo=False,max_overflow=5)
# 连接mysql数据库，echo为是否打印结果

Base = declarative_base()  # 生成orm基类


class User(Base):  # 继承生成的orm基类
    __tablename__ = "user"  # 表名
    id = Column(Integer, primary_key=True)  # 设置主键
    user_name = Column(String(32))
    user_password = Column(String(64))


class Admin(Base):
    __tablename__ = "admin"
    id = Column(Integer, primary_key=True)
    username = Column(String(32))
    password = Column(String(64))




stmt = delete(User)\
    .filter(User.user_name == "jack" )\
    .filter(User.user_password == "123456")  #这里我们使用delete方法
Session = sa.orm.sessionmaker(engine)
with Session() as session:
    session.execute(stmt)
    session.commit()

请注意，我们对 delete 语句应用了一些过滤。我们当然可以在前一部分的 select 语句中做同样的事情。

• 更新一条记录

import sqlalchemy as sa
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column,String,Integer
from sqlalchemy import update

engine = sa.create_engine("mysql+pymysql://root:root@127.0.0.1/test",encoding="utf-8",echo=True,max_overflow=5)
# 连接mysql数据库，echo为是否打印结果

Base = declarative_base()  # 生成orm基类


class User(Base):  # 继承生成的orm基类
    __tablename__ = "user"  # 表名
    id = Column(Integer, primary_key=True)  # 设置主键
    user_name = Column(String(32))
    user_password = Column(String(64))


class Admin(Base):
    __tablename__ = "admin"
    id = Column(Integer, primary_key=True)
    username = Column(String(32))
    password = Column(String(64))


stmt = update(User)\
    .filter(User.user_name == "jack")\
    .filter(User.user_password == "123456")\
    .values(user_name="Elio", user_password="654321")

Session = sa.orm.sessionmaker(engine)
with Session() as session:
    session.execute(stmt)
    session.commit()

ORM 的更多优点：验证数据

因为我们已经在类中定义了我们的表并且还使用类来创建新记录，所以我们可以添加一些非常高级的验证。有人试图添加一个 300 岁的用户的数据。我们可以很容易地更新用户表模型来验证提供的年龄：

import sqlalchemy as sa
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column,String,Integer
from sqlalchemy import update

engine = sa.create_engine("mysql+pymysql://root:root@127.0.0.1/test",encoding="utf-8",echo=True,max_overflow=5)
# 连接mysql数据库，echo为是否打印结果

Base = declarative_base()  # 生成orm基类


class User(Base):  # 继承生成的orm基类
    __tablename__ = "user"  # 表名
    id = Column(Integer, primary_key=True)  # 设置主键
    user_name = Column(String(32))
    user_password = Column(String(64))
    user_age = Column(Integer)
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        if (self.user_age > 110):
            raise ValueError("Too old for a user!")


class Admin(Base):
    __tablename__ = "admin"
    id = Column(Integer, primary_key=True)
    username = Column(String(32))
    password = Column(String(64))


newUser = User(user_name="Alice", user_password="123456",user_age=112)

Session = sa.orm.sessionmaker(engine)
with Session() as session:
    session.add(newUser)
    session.commit()

如上图所见我们检查提供的年龄是否大于 110，如果是则抛出错误。这可以防止将此记录插入到我们的数据库中。

结论

我们介绍了 SQLAlchemy 对象关系映射器 (ORM) 的基础知识。更多的重点放在如何真正从头开始使用 ORM。你现在应该对Engine、Session、ORM、Query等基本概念比较熟悉了。另外还给出了一些在实际工作中如何处理ORM问题的技巧，比如如何使用SQLAlchemy创建数据库以及如何从现有表创建 ORM 类，而不是从头开始编写所有内容。

如果你发现我的任何文章对你有帮助或者有用，麻烦点赞或者转发。 谢谢！