Откройте страницу, если чтение отношений создаёт дополнительные SQL-запросы или возвращает неожиданный состав коллекции. Выберите приём по нужным данным и ограничениям запроса. Справочник SQLAlchemy · Схема моделей. Для первого знакомства откройте самостоятельный синхронный пример N+1: две модели в одном файле.
| Ситуация | Приём | Карточка / пример |
|---|---|---|
| Слишком много запросов к БД при чтении коллекций | Посчитать запросы в новой сессии (Session) |
Найти N+1 · Самостоятельная программа |
| Нужны все посты списка пользователей | selectinload: отдельный SELECT для группы |
Выбор и цена · Карточка |
| Нужна небольшая коллекция без отдельного SELECT | joinedload: строки связи в том же SELECT |
Коллекция и unique |
| Нужен автор каждого поста | Сравнить повторение полей и число SELECT | Одиночная связь |
| Непредвиденная загрузка должна вызвать ошибку | raiseload: запрет загрузки отношения при обращении к атрибуту |
Запретить lazy-загрузку |
| Фильтр по дочерней таблице; нужна полная коллекция | Явный JOIN + selectinload |
Отфильтровать родителей |
| Нужна только выбранная часть коллекции | contains_eager: заполнить отношение строками своего JOIN |
Загрузить частичную коллекцию |
| Коллекция уже загружена | populate_existing: явно обновить состояние объектов |
Обновить загруженную коллекцию |
| Результат не помещается в память | Отдельно выбрать пакетную обработку | Большие выборки |
| Параметр | Значение |
|---|---|
| Уровень | Средний; частичные коллекции и состояние Session — продвинутый |
| Предпосылки | Для N+1 — Python и основы SELECT: один файл с объяснениями. Остальные карточки используют SQL JOIN, Session, demo_models.py и seed() из подготовки лабораторной |
| Самостоятельный N+1 | Отдельная программа, версии и границы; расширенный набор использует общую схему |
| Зависимости | Синхронная ORM SQLAlchemy 2.1.8 и SQLite в памяти; подготовка |
| Нужные данные и ограничения | С чего начать | Цена и условие пересмотра |
|---|---|---|
| Все коллекции списка родителей; размеры коллекций различаются или велики | selectinload |
Дополнительные SELECT по пакетам ключей; поля родителей не повторяются для каждого ребёнка |
| Небольшой ограниченный набор родителей и детей; отдельный SELECT нежелателен | Сравнить joinedload с selectinload |
JOIN повторяет поля родителя для каждого ребёнка; коллекция требует unique() |
| Один связанный объект для каждой строки; повторение его полей приемлемо | Обычно joinedload |
Нет дополнительных строк от этой связи, но поля связанного объекта повторяются |
| Многие строки ссылаются на одни объекты с объёмными полями | Сравнить selectinload одиночной связи с joinedload |
Дополнительный SELECT может сократить повторную передачу полей; выигрыш требует измерения |
| Отношение может не понадобиться | Lazy loading | При чтении возможен SQL; для простой связи «многие к одному» identity map иногда исключает SELECT |
| Незапланированное чтение должно вызвать ошибку | raiseload |
Ошибка вместо lazy SELECT; SQL внутри flush этим не запрещён |
| Нужна только выбранная часть коллекции | Фильтр и contains_eager |
Явно отделите частичную коллекцию от полной; карточка |
Чтобы сравнить число SELECT на одних данных, посмотрите запросы по шагам или запустите самостоятельный пример N+1.
Сначала определите состав родителей и нужных отношений.
ORM сопоставляет строки таблиц с объектами Python.
Родитель здесь — объект исходного запроса, например пользователь в select(User).
User.posts — коллекция постов пользователя, а Post.author — один автор.
Коллекция может быть пустой; необязательная одиночная связь может содержать None.
Укажите, нужна полная коллекция, её часть или один связанный объект.
Затем оцените число строк, ширину строки и допустимое число обращений к БД.
Ширина строки зависит от выбранных столбцов и размера их значений.
Identity map внутри Session сопоставляет идентификатору строки уже загруженный объект.
Lazy loading загружает отношение при обращении к незагруженному атрибуту.
Eager loading заранее загружает отношение вместе с исходным запросом или дополнительными SELECT.
И selectinload, и joinedload выполняют eager loading.
Для коллекции один родитель может соответствовать нескольким строкам результата SQL.
unique() оставляет один ORM-объект на идентификатор в результате Python; переданные строки SQL остаются прежними.
Несколько независимых коллекций в одном SELECT могут перемножить число строк одного родителя.
Выбирайте стратегию отдельно для каждого отношения.
Один SELECT не гарантирует меньшие время, память или сетевой трафик.
PK — первичный ключ, который однозначно определяет строку таблицы.
LIMIT ограничивает число строк, а OFFSET пропускает начало результата.
yield_per читает результат порциями вместо накопления всей выборки сразу.
| Условие | Что проверить |
|---|---|
Страница родителей с LIMIT / OFFSET |
Ограничьте родителей с устойчивым ORDER BY, например по PK. Select-in загружает коллекции выбранной страницы отдельно |
| Та же страница с joinedload коллекции | SQLAlchemy оборачивает исходный SELECT в подзапрос перед JOIN загрузки. Проверьте сложность SQL и объём строк; LIMIT не запрещает joinedload |
Явный JOIN по дочерней таблице и LIMIT |
Лимит может ограничить строки JOIN, а не число разных родителей. unique() после запроса эту страницу не исправляет |
| Составной первичный ключ: несколько столбцов идентификатора | Select-in требует tuple IN — проверки списка кортежей ключей. SQL Server этот синтаксис не поддерживает; выбор не сводится к двум стратегиям |
Пакетное чтение через yield_per |
Joinedload коллекции несовместим. Select-in зависит от поддержки независимых курсоров драйвером; отдельный материал |
Блокировка строк через SELECT … FOR UPDATE |
JOIN загрузки может затронуть блокировкой связанную таблицу. Проверьте поведение СУБД перед выбором joinedload |
Для составных ключей на SQL Server рассмотрите subqueryload с его ограничениями.
Карточка N+1 использует самостоятельную программу.
Остальные фрагменты используют подготовленный engine и новую Session для каждого сравнения.
Полные зависимости и подготовка указаны отдельно.
Ситуация: сначала загружен список пользователей, затем код читает user.posts для каждого пользователя.
При lazy-загрузке первое чтение незагруженной коллекции выполняет SELECT.
Для N пользователей получается N+1 запросов: один для списка и N для коллекций.
Самостоятельная программа содержит две модели, подготовку SQLite в памяти и команду запуска.
Пример — фрагмент функции read_users из этой программы без предварительной загрузки:
stmt = select(User).order_by(User.id)
users = session.scalars(stmt).all()
rows = [(user.name, sorted(post.title for post in user.posts)) for user in users]session — новая Session внутри read_users; сессия выполняет запросы и хранит состояние объектов.
select(User) описывает запрос, а session.scalars(stmt).all() выполняет запрос и возвращает список пользователей.
Изменение: добавьте .options(selectinload(User.posts)) к запросу пользователей.
Этот приём заранее читает посты для группы пользователей отдельным SELECT с условием IN.
Такую предварительную загрузку называют eager loading.
Полная программа сравнивает оба варианта и считает SELECT до конца чтения коллекций.
Результат учебного набора: [('alice', ['Python', 'SQL']), ('bob', [])] в обоих вариантах.
Новая Session с lazy-загрузкой выполняет три SELECT, а с selectinload — два.
Даже пустая коллекция Bob требует загрузки.
Считайте запросы до конца чтения отношений, включая сериализацию ответа.
Состояние прежней Session может скрыть дополнительные запросы.
Число запросов зависит от объёма и формы загрузки; два SELECT не являются общей гарантией.
После измерения выберите стратегию загрузки по размеру коллекции и стоимости обращения к БД.
Ограничения минимального примера и полная лабораторная описаны отдельно.
Ситуация: для списка пользователей нужны все посты, включая пустые коллекции.
Размеры коллекций могут различаться; повторять поля пользователя для каждого поста нежелательно.
Изменение: начните с selectinload, если дополнительный SELECT допустим.
Простой внешний ключ этой модели поддерживает такую загрузку.
Пример — фрагмент с подготовленным engine:
from sqlalchemy import select
from sqlalchemy.orm import Session, selectinload
from demo_models import User
with Session(engine) as session:
users = session.scalars(
select(User).options(selectinload(User.posts)).order_by(User.id)
).all()
sizes = [len(user.posts) for user in users]Результат учебного набора: sizes == [2, 0], два SELECT вместо трёх.
Для большей выборки число SELECT зависит от числа пакетов ключей и уровней отношений.
Для составного ключа нужен tuple IN — условие IN со списком кортежей ключей; поддержка зависит от СУБД.
Например, SQL Server не поддерживает такой вариант select-in загрузки составного ключа.
Для вложенных comments добавьте selectinload(User.posts).selectinload(Post.comments).
Это отдельный уровень загрузки и дополнительные запросы.
Проверки количества и содержимого
Ситуация: нужны пользователи со всеми постами; набор родителей и коллекции невелики.
Дополнительное обращение к БД нежелательно, а повторение полей пользователя допустимо.
Изменение: сравните joinedload с select-in загрузкой на тех же данных.
Добавьте unique() при чтении результата коллекции.
Пример — фрагмент с подготовленным engine:
from sqlalchemy import select
from sqlalchemy.orm import Session, joinedload
from demo_models import User
with Session(engine) as session:
users = session.scalars(
select(User).options(joinedload(User.posts)).order_by(User.id)
).unique().all()
sizes = [len(user.posts) for user in users]Результат учебного набора: те же [2, 0], один SELECT.
SQL возвращает три строки: две для постов Alice и одну для Bob без постов.
Поля Alice передаются дважды, хотя Python возвращает одного пользователя Alice.
По умолчанию LEFT OUTER JOIN сохраняет пользователя без постов.
LEFT OUTER JOIN возвращает левую строку, даже когда связанной правой строки нет.
Без unique() SQLAlchemy требует явной обработки повторений и вызывает InvalidRequestError при чтении результата.
unique() не уменьшает число строк, переданных из БД.
Большие коллекции и несколько JOIN могут заметно увеличить результат SQL.
joinedload не заменяет явный join() для фильтра по дочерней таблице.
Проверка успеха и отказа без unique
Ситуация: для списка постов нужен автор каждого поста.
Объём повторяемых полей автора приемлем; желательно получить данные одним SELECT.
Изменение: начните с joinedload(Post.author).
Связь Post.author имеет тип many-to-one: многие посты могут ссылаться на одного автора.
Пример — фрагмент с подготовленным engine:
from sqlalchemy import select
from sqlalchemy.orm import Session, joinedload
from demo_models import Post
with Session(engine) as session:
posts = session.scalars(
select(Post).options(joinedload(Post.author)).order_by(Post.id)
).all()
authors = [post.author.name for post in posts]Результат учебного набора: два имени alice, один SELECT.
Одиночная связь не размножает строки как коллекция; unique() здесь не требуется.
По умолчанию joinedload использует LEFT OUTER JOIN и сохраняет родителей без связанного объекта.
Если много постов ссылаются на одного автора с объёмными полями, сравните select-in загрузку.
В том же фрагменте замените опцию на selectinload(Post.author) и импортируйте selectinload из sqlalchemy.orm.
Для двух учебных постов получите тех же авторов через два SELECT.
Первый SELECT читает посты; второй читает одного общего автора без повторения его полей в каждой строке поста.
При joinedload SQL передаёт поля Alice дважды, хотя identity map создаёт один объект автора.
Identity map сама по себе не уменьшает данные результата SQL.
Для простой lazy many-to-one связи уже загруженный автор иногда исключает дополнительный SELECT.
Не включайте innerjoin=True только ради уменьшения числа строк.
INNER JOIN сохраняет лишь строки с найденным связанным объектом.
Для необязательной связи такой JOIN исключит родителей без объекта.
Используйте его, только если наличие связанного объекта гарантировано или исключение родителей намеренно.
Полная проверка
Ситуация: неожиданный SQL при формировании ответа должен стать ошибкой теста. Разрешите нужное отношение и запретите остальные lazy-загрузки:
from sqlalchemy import select
from sqlalchemy.orm import Session, raiseload, selectinload
from demo_models import User
with Session(engine) as session:
users = session.scalars(
select(User).options(selectinload(User.posts), raiseload("*")).order_by(User.id)
).all()
sizes = [len(user.posts) for user in users]
# users[0].profile не загружен: обращение вызовет InvalidRequestError.Результат: posts доступны; обращение к незагруженному profile вызывает ошибку вместо SELECT.
Wildcard "*" действует и на отношения загруженных дочерних объектов.
raiseload относится к отношениям, а не ко всем скалярным колонкам.
Внутренний flush может выполнить нужные загрузки, обходя raiseload.
Проверка ошибки и отсутствия дополнительного SELECT
Выполните полную лабораторную со сравнением загрузок и отказами. Учебное число SELECT не является измерением ускорения приложения.