【SQLAlchemy】个人快速学习笔记

一.核心概念

SQLAlchemy是一个功能强大的Python ORM（对象关系映射）库，它提供了许多核心概念和组件来帮助开发人员进行数据库操作。下面是SQLAlchemy的一些核心概念：

1. Engine（引擎）：

Engine是SQLAlchemy的核心组件之一，它用于管理数据库连接。通过Engine，你可以创建数据库连接池，执行SQL语句，管理事务等操作。

2. Session（会话）：

Session是SQLAlchemy用于管理对象持久化的主要接口。它充当了与数据库交互的上下文，提供了一组方法来执行CRUD操作（创建、读取、更新、删除）以及其他数据库操作。

3. declarative_base()：

这是SQLAlchemy提供的一个函数，用于创建基础模型类 。通过继承这个基础模型类，你可以定义模型类来映射数据库表。该函数还提供了一些方便的属性和方法，例如query属性用于执行查询操作。（类似于MP中的IMapper提供的那些CRUD）

4.Table（表）：

Table是SQLAlchemy用于表示数据库表的对象。你可以使用Table来定义表的结构，包括表名、列名、列类型、约束等。表对象提供了一些方法用于执行数据库操作。

5.Column（列）：

Column是SQLAlchemy用于表示数据库表的列的对象。你可以使用Column来定义列的属性，如列名、数据类型、约束等。

6.Relationship（关联关系）：

SQLAlchemy允许你定义模型类之间的关联关系，例如一对一关系、一对多关系、多对多关系等。通过定义关联关系，你可以在模型类之间进行关联查询和级联操作。

7.查询对象（Query）：

SQLAlchemy提供了查询对象来执行复杂的数据查询。查询对象提供了一系列方法来进行过滤、排序、聚合等操作，并且支持链式调用。（Java中的Stream流）

java中的：

userMapper.selectList(
    Wrappers.lambdaQuery(User.class)
            .gt(User::getAge, 18)
            .orderByAsc(User::getCreateTime)
            .last("limit 10")
);

python中的：

session.query(User)\
       .filter(User.age > 18)\
       .order_by(User.create_time.asc())\
       .limit(10)\
       .all()

SQLAlchemy Query	Java Stream	作用
filter()	filter()	过滤条件
order_by()	sorted()	排序
limit()	limit()	限制条数
group_by()	collect()	分组聚合
join()	无（DB 层面关联）	表连接
all()	collect()	执行并返回结果
first()	findFirst()	获取第一个

8. 事务管理：

SQLAlchemy允许你在会话中管理数据库事务。你可以使用session.begin()来开始一个事务，使用session.commit()提交事务，使用session.rollback()回滚事务。

二.Engine

2.1 准备环境

# 确保在 python310 环境中安装（使用完整路径强制安装到目标环境）
E:\PythonRootDictionary\software\Anaconda\InstallContent\envs\python310\python.exe -m 
pip install pymysql -i https://pypi.tuna.tsinghua.edu.cn/simple

2.2 创建MySQL Engine

# 创建Engine
from sqlalchemy import create_engine, text

# MySQL 连接字符串格式:
# mysql+pymysql://用户名:密码@主机:端口/数据库名?charset=utf8mb4

DATABASE_URL = "mysql+pymysql://root:root@localhost:3306/ecommerce?charset=utf8mb4"


engine = create_engine(
    DATABASE_URL,
    echo=True,          # 打印 SQL (学习阶段强烈建议)
    pool_size=10,       # 连接池大小
    max_overflow=20     # 最大溢出连接数
)

2.3 执行SQL

先拿到connection再execute

# 先拿到connection再execute
with engine.begin() as conn:
    conn.execute(text("""
        CREATE TABLE IF NOT EXISTS learn_users (
            id INT PRIMARY KEY AUTO_INCREMENT,
            username VARCHAR(50) NOT NULL,
            email VARCHAR(100)
        )
    """))

2.4 插入数据

# 插入数据（批量 + 参数绑定，防 SQL 注入）
with engine.begin() as conn:
    conn.execute(
        text("INSERT INTO users (username, email) VALUES (:username, :email)"),
        [
            {"username": "alice", "email": "alice@test.com"},
            {"username": "bob", "email": "bob@test.com"}
        ]
    )

2.5 查询数据

# 查询数据
with engine.connect() as conn:
    result = conn.execute(text("SELECT id, username, email FROM users"))
    for row in result:
        print(row.id, row.username, row.email)

三.Session和declarative_base()

3.1 准备环境

E:\PythonRootDictionary\software\Anaconda\InstallContent\envs\python310\python.exe -m
pip install sqlalchemy pymysql

3.2 通过Session工厂创建Session。创建基础模型

# 通过Session工厂创建 Session
SessionLocal = sessionmaker(
    bind = engine, # 绑定引擎
    autocommit = False, # 默认是 False, 如果设置为 True, 则每次查询都会自动提交
    autoflush = False # 默认是 False, 如果设置为 True, 则每次查询都会自动刷新
)
Base = declarative_base() # 创建基类

3.3 定义ORM模型

# 定义ORM模型:
# Base 是通过 declarative_base() 创建的基础模型类
# __tablename__ 指定映射到数据库的表名
# index=True 会为该字段创建索引，提升查询效率
# nullable=False 表示该字段不允许为空
class User(Base):
    # 表名
    __tablename__ = "users"

    # 字段id : 整型，主键，自增，索引
    id = Column(Integer, primary_key=True, index=True) # 这里建立索引有点多余，因为id是主键，默认就是索引。仅作为学习参数案例
    username = Column(String(50), nullable=False)
    email = Column(String(100),index = True)

3.4 创建表（一次即可）

# 创建表
Base.metadata.create_all(bind=engine) # 根据你定义的所有继承自 Base 的 ORM 模型，自动在数据库中创建对应的表（如果表还不存在）✅

举例子：

执行 Base.metadata.create_all(bind=engine) 后，它会自动帮你执行：

CREATE TABLE IF NOT EXISTS users (
            id INT PRIMARY KEY AUTO_INCREMENT,
            username VARCHAR(50) NOT NULL,
            email VARCHAR(100)
        )

3.5 CRUD

3.5.1 添加

step1: 创建Session

# 通过Session工厂给 Session绑定属性
SessionLocal = sessionmaker(
    bind = engine, # 绑定引擎
    autocommit = False, # 默认是 False, 如果设置为 True, 则每次查询都会自动提交
    autoflush = False # 默认是 False, 如果设置为 True, 则每次查询都会自动刷新
)

# 创建session
session = SessionLocal()

step2:插入数据

try:
    user = User(username="alice", email="alice@test.com")
    session.add(user)
    session.commit()
    session.refresh(user)  # 刷新，拿到数据库生成的 id
    print("新用户 ID:", user.id)
except Exception as e:
    session.rollback()
    print("出错了:", e)
finally:
    session.close()

• try 块：执行业务逻辑（创建用户、添加到会话、提交事务）
• session.add(user)：将用户对象添加到会话缓存（暂未入库）
• session.commit()：提交事务，将缓存数据写入数据库
• session.refresh(user) ：从数据库刷新对象状态，获取自增主键 id
• except 块 ：捕获异常，执行 rollback() 回滚事务，保证数据一致性
• finally 块 ：无论是否异常，都会执行 session.close() 关闭会话，释放资源

3.5.2 查询

# 查询数据
session = SessionLocal()
users = session.query(User).all()
for user in users:
    print(user.id, user.username, user.email)
session.close()

3.5.3 条件查询

# 条件查询 : 查询alice
session = SessionLocal()
alices = session.query(User).filter(User.username == "alice")
for alice in alices:
    print(alice.id, alice.username, alice.email)

• filter() ：对应 SQL 的 WHERE 子句，用于添加查询条件
• first() ：获取查询结果中的第一条数据，若不存在则返回 None

3.5.4 更新数据（条件查询出来在具体修改，commit提交到数据库）

# 更新 : 查询出来,具体更新属性再commit
session = SessionLocal()
yuxinze = session.query(User).filter(User.username == "于信泽")
yuxinze.update({"username": "于信泽dsb"})
session.commit()
session.close()

3.5.5 删除数据（条件查询出来在具体删除，commit提交到数据库）

# 删除 : 查询出来,具体删除再commit
session = SessionLocal()
yuxinze = session.query(User).filter(User.username == "于信泽3")
session.delete(yuxinze)
session.commit()
session.close()

3.6 事务 & 回滚