Skip to content

Latest commit

 

History

History
277 lines (207 loc) · 25.5 KB

relationship-loading.md

File metadata and controls

277 lines (207 loc) · 25.5 KB

Устранить N+1 и выбрать загрузку отношений

English

Откройте страницу, если чтение отношений создаёт дополнительные 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 для каждого сравнения. Полные зависимости и подготовка указаны отдельно.

Найти N+1

Ситуация: сначала загружен список пользователей, затем код читает 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

Ситуация: для списка пользователей нужны все посты, включая пустые коллекции. Размеры коллекций могут различаться; повторять поля пользователя для каждого поста нежелательно. Изменение: начните с 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

Ситуация: нужны пользователи со всеми постами; набор родителей и коллекции невелики. Дополнительное обращение к БД нежелательно, а повторение полей пользователя допустимо. Изменение: сравните 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 исключит родителей без объекта. Используйте его, только если наличие связанного объекта гарантировано или исключение родителей намеренно. Полная проверка

Обнаружить незапланированную lazy-загрузку

Ситуация: неожиданный 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 не является измерением ускорения приложения.

Источники