各位靓仔靓女，晚上好！我是你们今晚的导游，带大家走进 SQLAlchemy 懒加载和立即加载的奇妙世界。准备好迎接一场性能优化的头脑风暴了吗？ Let’s go!
今天我们要聊的是 SQLAlchemy 中两种加载关联关系数据的方式：懒加载（Lazy Loading）和立即加载（Eager Loading）。它们就像两种不同风格的大厨，烹饪关联数据的方式截然不同，对性能的影响也天差地别。选对了，你的程序飞一般流畅；选错了，可能卡成 PPT。
一、什么是懒加载和立即加载？
想象一下，你正在开发一个博客系统，数据库中有两个表：users (用户) 和 posts (文章)。每个用户可以写很多文章，所以 users 和 posts 之间存在一对多的关系。
-
懒加载 (Lazy Loading)： 就像一个勤俭持家的好男人，不到万不得已绝不出手。当你从数据库中获取一个
User对象时，默认情况下，User相关的Post对象并不会立即加载。只有当你真正需要访问User的posts属性时，SQLAlchemy 才会发送一条新的 SQL 查询来获取这些Post对象。from sqlalchemy import create_engine, Column, Integer, String, ForeignKey from sqlalchemy.orm import relationship, sessionmaker from sqlalchemy.ext.declarative import declarative_base Base = declarative_base() class User(Base): __tablename__ = 'users' id = Column(Integer, primary_key=True) name = Column(String) posts = relationship("Post", back_populates="author") def __repr__(self): return f"<User(name='{self.name}')>" class Post(Base): __tablename__ = 'posts' id = Column(Integer, primary_key=True) title = Column(String) content = Column(String) user_id = Column(Integer, ForeignKey('users.id')) author = relationship("User", back_populates="posts") def __repr__(self): return f"<Post(title='{self.title}')>" engine = create_engine('sqlite:///:memory:') # 使用内存数据库方便演示 Base.metadata.create_all(engine) Session = sessionmaker(bind=engine) session = Session() # 创建一些示例数据 user1 = User(name='张三') user2 = User(name='李四') post1 = Post(title='Python 入门', content='Python 真是太棒了！', author=user1) post2 = Post(title='SQLAlchemy 教程', content='SQLAlchemy 真香！', author=user1) post3 = Post(title='Flask Web 开发', content='Flask 简单易用！', author=user2) session.add_all([user1, user2, post1, post2, post3]) session.commit() # 懒加载示例 user = session.query(User).filter_by(name='张三').first() print(user) # 此时只加载了 User 对象 # <User(name='张三')> print(user.posts) # 访问 user.posts 时，才会触发新的 SQL 查询加载 Post 对象 # [<Post(title='Python 入门')>, <Post(title='SQLAlchemy 教程')>]在这个例子中，当我们执行
session.query(User).filter_by(name='张三').first()时，实际上只从数据库中获取了User对象。只有当我们访问user.posts属性时，SQLAlchemy 才会执行一条新的 SQL 查询来获取张三的所有文章。 -
立即加载 (Eager Loading)： 就像一个霸道总裁，一次性把所有东西都准备好。当你从数据库中获取一个
User对象时，SQLAlchemy 会立即加载User相关的Post对象，通常是通过使用JOIN语句。from sqlalchemy.orm import joinedload # 立即加载示例 user = session.query(User).options(joinedload(User.posts)).filter_by(name='张三').first() print(user) # 此时加载了 User 对象和相关的 Post 对象 # <User(name='张三')> print(user.posts) # 访问 user.posts 时，不需要再执行新的 SQL 查询 # [<Post(title='Python 入门')>, <Post(title='SQLAlchemy 教程')>]在这个例子中，我们使用了
joinedload(User.posts)选项，告诉 SQLAlchemy 在查询User对象时，立即加载相关的Post对象。因此，当我们执行session.query(User).options(joinedload(User.posts)).filter_by(name='张三').first()时，SQLAlchemy 会执行一条包含JOIN语句的 SQL 查询，一次性获取User对象和所有相关的Post对象。
二、N+1 查询问题
懒加载虽然看起来很节约资源，但如果使用不当，很容易掉入 N+1 查询的陷阱。
什么是 N+1 查询？ 假设你需要获取所有用户的姓名以及他们发布的文章的标题。如果你使用懒加载，你的代码可能会这样写：
users = session.query(User).all()
for user in users:
print(f"用户：{user.name}")
for post in user.posts:
print(f" - {post.title}")这段代码看起来很简单，但实际上它会执行 N+1 条 SQL 查询，其中 N 是用户的数量。
- 首先，执行一条 SQL 查询获取所有用户：
SELECT * FROM users。 - 然后，对于每个用户，执行一条 SQL 查询获取该用户的所有文章：
SELECT * FROM posts WHERE user_id = user.id。
当用户数量很大时，N+1 查询会导致大量的数据库交互，极大地降低程序的性能。 想象一下，你有 1000 个用户，那么这段代码会执行 1001 条 SQL 查询！ 数据库服务器估计想把你拉黑。
三、立即加载的几种方式
为了避免 N+1 查询问题，我们可以使用立即加载。 SQLAlchemy 提供了几种不同的立即加载方式：
-
joinedload： 使用LEFT OUTER JOIN在一条 SQL 查询中获取所有相关数据。这是最常用的立即加载方式，通常性能最好。from sqlalchemy.orm import joinedload users = session.query(User).options(joinedload(User.posts)).all() for user in users: print(f"用户：{user.name}") for post in user.posts: print(f" - {post.title}")这段代码只会执行一条 SQL 查询，一次性获取所有用户和他们的文章。
-
subqueryload： 先执行一条 SQL 查询获取所有用户，然后执行一条子查询获取所有相关的文章。适用于关联关系的数据量比较大的情况，可以避免JOIN语句带来的性能问题。from sqlalchemy.orm import subqueryload users = session.query(User).options(subqueryload(User.posts)).all() for user in users: print(f"用户：{user.name}") for post in user.posts: print(f" - {post.title}")这段代码会执行两条 SQL 查询：一条查询所有用户，一条子查询查询所有用户的文章。
-
selectinload： 先执行一条 SQL 查询获取所有用户，然后为每个用户执行一条SELECT IN查询获取相关的文章。 适用于关联关系的数据量非常大的情况，可以避免JOIN语句和子查询带来的性能问题。from sqlalchemy.orm import selectinload users = session.query(User).options(selectinload(User.posts)).all() for user in users: print(f"用户：{user.name}") for post in user.posts: print(f" - {post.title}")这段代码会执行一条查询所有用户的SQL，然后根据用户id执行
SELECT IN查询获取所有文章。
四、性能考量：懒加载 vs 立即加载
| 特性 | 懒加载 (Lazy Loading) | 立即加载 (Eager Loading) |
|---|---|---|
| SQL 查询数量 | 可能会导致 N+1 查询，查询数量取决于访问关联关系的次数 |
通常只需要一条 SQL 查询 (使用 joinedload) 或少数几条 (使用 subqueryload 或 selectinload) |
| 内存占用 | 初始内存占用较小，只有在访问关联关系时才会加载数据 | 初始内存占用较大，一次性加载所有相关数据 |
| 适用场景 | 关联关系的数据量较小，或者不需要频繁访问关联关系 | 关联关系的数据量较大，或者需要频繁访问关联关系 |
| 优化建议 | 避免 N+1 查询，使用 contains_eager 或 with_polymorphic |
根据实际情况选择合适的立即加载方式 (joinedload, subqueryload, selectinload) |
什么时候应该使用懒加载？
- 当你的程序只需要访问少量数据的关联关系时。
- 当你希望减少初始内存占用时。
- 当你确定不会出现
N+1查询问题时。
什么时候应该使用立即加载？
- 当你的程序需要频繁访问数据的关联关系时。
- 当你希望避免
N+1查询问题时。 - 当你知道你需要访问所有相关数据时。
五、如何选择合适的加载方式？
选择合适的加载方式是一门艺术，需要根据具体的应用场景进行权衡。以下是一些建议：
- 评估关联关系的数据量： 如果关联关系的数据量很小，懒加载可能是一个不错的选择。 如果关联关系的数据量很大，立即加载通常更合适。
- 分析程序的访问模式： 如果你的程序需要频繁访问关联关系，立即加载通常会带来更好的性能。 如果你的程序只需要访问少量数据的关联关系，懒加载可能更合适。
- 使用性能分析工具： 使用 SQLAlchemy Profiler 或其他性能分析工具来分析你的程序的 SQL 查询，找出潜在的性能瓶颈。
- 进行基准测试： 针对不同的加载方式进行基准测试，选择性能最好的方案。
六、一些高级技巧
-
contains_eager： 如果你已经通过其他方式加载了关联关系，可以使用contains_eager来告诉 SQLAlchemy 不要再次加载这些数据。from sqlalchemy.orm import contains_eager users = session.query(User).join(User.posts).options(contains_eager(User.posts)).all() for user in users: print(f"用户：{user.name}") for post in user.posts: print(f" - {post.title}")在这个例子中，我们使用了
join(User.posts)来确保在查询User对象时，posts关系已经被加载。然后，我们使用contains_eager(User.posts)来告诉 SQLAlchemy 不要再次加载这些数据。 -
with_polymorphic： 如果你使用了多态关联，可以使用with_polymorphic来指定需要加载的具体类型。from sqlalchemy.orm import with_polymorphic # 假设有一个 Animal 基类和 Dog, Cat 子类 Animal = declarative_base() class Animal(Animal): __tablename__ = 'animals' id = Column(Integer, primary_key=True) type = Column(String(50)) __mapper_args__ = { 'polymorphic_identity': 'animal', 'polymorphic_on': type } class Dog(Animal): __tablename__ = 'dogs' id = Column(Integer, ForeignKey('animals.id'), primary_key=True) name = Column(String(50)) __mapper_args__ = { 'polymorphic_identity': 'dog', } class Cat(Animal): __tablename__ = 'cats' id = Column(Integer, ForeignKey('animals.id'), primary_key=True) breed = Column(String(50)) __mapper_args__ = { 'polymorphic_identity': 'cat', } AnimalPolymorphic = with_polymorphic(Animal, [Dog, Cat]) animals = session.query(AnimalPolymorphic).all() for animal in animals: print(animal)在这个例子中，我们使用了
with_polymorphic来指定需要加载Dog和Cat类型的数据。 -
使用缓存： 对于一些不经常变化的数据，可以使用缓存来减少数据库的访问次数。 SQLAlchemy 可以与多种缓存系统集成，例如 Redis 或 Memcached。
七、总结
懒加载和立即加载是 SQLAlchemy 中两种重要的加载关联关系数据的方式。 懒加载可以减少初始内存占用，但可能会导致 N+1 查询问题。 立即加载可以避免 N+1 查询问题，但会增加初始内存占用。 选择合适的加载方式需要根据具体的应用场景进行权衡。
记住，没有银弹！ 最佳实践是根据你的具体需求进行实验，并使用性能分析工具来找到最适合你的解决方案。
今天的分享就到这里，希望对大家有所帮助！ 祝大家编码愉快，远离 Bug！ 谢谢大家！