g=3.69×1.1×1.4=5.68кН/м

l₀=5650-750×2=4150мм

М_конс=gx0,75ч0,75/2=5,68×0.75×0.375=1.6 Кн x м

Определяем арматуру на опоре (в верхней зоне)

h=240мм

h₀=240-25=215мм

=>,

2Ø10   А-III A_S=15,7см²

Сборник загрузки действий по событию

Infor CloudSuite Промышленная онлайн-справка

Примечание. Получить доступ к этой форме можно только из формы «Действия при событии».

Используйте эту форму для создания действия при событии, которое загружает указанную коллекцию, связанную с IDO. Вы можете использовать различные варианты в этой форме, чтобы ограничить объем данных, возвращаемых этим действием события.

Данные, полученные этим действием, хранятся в «наборе результатов», к которому вы затем должны обращаться для дальнейших действий.

Основная цель типа действия Load IDO Collection — увидеть извлеченные свойства, поэтому действие Load IDO Collection обычно следует одно или несколько выражений PROPERTY () или FILTERPROPERTY ().

Выражение ROWS () необходимо, если вы заранее не знаете, сколько строк будет извлечено на основе FILTER ().В этом случае вы используете его для ограничения значений, передаваемых в PROPERTY () и FILTERPROPERTY () для аргумента номера строки. Этот особенно полезно, когда вы выполнили несколько действий Load IDO Collection и должны хранить их результаты отдельно.

Выберите Distinct так что действие события возвращает только уникальные комбинации свойств.

Примечание. Тип действия Load Collection аналогичен типу действия тип действия Dispatch Load Collection.Основное отличие состоит в том, что нагрузка Тип действия сбора выполняет запрос загрузки сбора в системе, из которой он инициируется; Dispatch Load Collection выполняет запрос Load Collection на удаленная система.

Тип ответа сбора нагрузки

Infor CloudSuite Промышленная онлайн-справка

Тип ответа Load Collection предоставляет возможность запрашивать IIDO сбор и вывод возвращаемых результатов в свойства, переменные или компоненты на форме.Он работает так же, как валидатор InCollection, за исключением того, что вы можете контролировать, когда происходит запрос, генерируя событие для этого типа обработчика.

При использовании типа ответа Load Collection помните об этих идеях:

• Вы должны, по крайней мере, указать коллекцию IDO, для которой вы хотите для выполнения запроса.
• Запрос автоматически ограничивается 2, потому что только первый строка доступна или может использоваться. Для случаев, когда вам нужен конкретный количество строк, возвращаемых клиенту, необходимо определить коллекцию на форме и привяжите его к сетке или другим компонентам.
• Вы можете указать, что запрос должен очистить выходные цели, если строки не возвращаются.
• Вы можете указать, что выходные цели не требуют проверки перед перемещением или сохранением результатов.
• Вы можете указать фильтр, который будет применяться к запрашиваемым записям.

Специальный сборщик мусора | Raleighnc.gov

Услуги по сбору предметов, которые обычно не принимаются службой твердых отходов

Перейти к:

Город Роли предлагает специальные коллекции для различных предметов, таких как мебель и бытовая техника, которые обычно не забираются в рамках обслуживания у обочины для бытовых клиентов.

• Бесплатная сборка крупногабаритных грузов предназначена для предметов, которые могут быть отправлены на свалку, но не помещаются в корзину для мусора. ПРИМЕЧАНИЕ. Некоторые предметы могут иметь право на сбор специального груза в городе, утилизацию на предприятии по переработке твердых отходов округа Уэйк или транспортировку частным мусоровозом.
• Сбор специального груза предназначен для крупных предметов, таких как бытовая техника и мебель, которые не подлежат бесплатному вывозу крупногабаритных грузов. Плата составляет 50 долларов за каждые 4 кубических ярда (достаточно, чтобы заполнить кровать стандартного пикапа).

Подробную информацию о том, что принято, как его подготовить и как запланировать получение, можно найти на этой странице.

Бесплатная доставка по сравнению с платной доставкой

Чтобы запланировать получение, позвоните в службу поддержки клиентов по телефону 919-996-3245. Будет ли с вас взиматься плата, будет зависеть от типа собранных вещей, размера груза и от того, живете ли вы в доме на одну семью или в многоквартирном комплексе.

Предметы, размещенные у тротуара до того, как вы планируете вывоз, подлежат административным штрафам и гражданским штрафам, как указано в Разделе 7 Кодекса города Роли.

Обратите внимание: городские власти больше не принимают перерабатываемый картон для крупногабаритной или специальной загрузки. В соответствии с поставленной муниципалитетом Роли устойчивой целью сократить выбросы парниковых газов в масштабах города на 80% к 2050 году, мы рекомендуем всем клиентам утилизировать картонные материалы в своих тележках у тротуаров или в специально отведенных местах.

Мы принимаем на переработку большинство видов картона. Гофрированный картон (транспортные коробки) подлежат вторичной переработке.Чтобы служба по утилизации твердых отходов могла собирать картон, он должен быть подготовлен в соответствии со следующими инструкциями:

• Полностью сплющить.
• Удалите весь упаковочный материал, включая пенопласт.
• Уменьшить на кусочки размером не более 3 х 3 футов.
• Поместите детали в корзину для вторичной переработки.

Запросить бесплатный крупногабаритный груз, специальный груз или вывоз электронных отходов

Как это работает

1. Позвоните в SWS, 919-996-3245, и сообщите свое имя, адрес, номер телефона в дневное время, описание предметов, которые необходимо забрать, и обычный день получения.
2. Для сбора специального груза оплатите сбор в размере 50 долларов за каждые четыре (4) кубических ярда груза. Плата должна быть получена до того, как предметы можно будет разместить у тротуара.
3. Выложите его в обычный день сбора до 7 часов утра (в летние месяцы до 6 часов утра). Размещайте предметы у обочины, а не на улице. Никакого громоздкого сбора в переулках, все предметы должны быть на главной улице.
4. Отмена должна быть произведена до 14:00. за день до запланированного вывоза, иначе вы лишитесь возможности бесплатного сбора крупногабаритных грузов и должны подождать 90 дней, чтобы перенести это время.

Примечание. Для одного адреса в 90-дневный период сбора крупногабаритных грузов может быть запланирована загрузка не более одного, четырех кубических ярдов.

Подготовка к сбору

Препарат

• Размещайте предметы у обочины, а не на улице
• Убедитесь, что предметы свободны от препятствий, таких как автомобили; низко свисающие конечности; знаки; или электрические столбы, линии и коробки.Наши грузовики не могут собирать предметы, которые мешают, и наши бригады не могут требовать перемещения транспортных средств. Нам нужно разрешение, чтобы делать свою работу.
• Разместите предметы на главной улице перед домом. Мы не можем собирать в переулках. Жители таунхауса должны размещать предметы в конце парковочного места, дальше всего от бордюров, зданий или почтовых ящиков.
• Не кладите в контейнеры предметы, которые не хотите выбрасывать.

Штрафы и пени

Город Роли предлагает сбор COG в дополнение к сбору крупногабаритных грузов и специальным услугам по сбору грузов.COG относится к коллекции больших предметов, которые не могут быть привязаны к определенному адресу или жителю. COG означает правительство, ориентированное на клиента, и в конечном итоге это незаконный сброс.

Помните, что владелец недвижимости обязан связаться с частным перевозчиком для переезда. Если житель выезжает и оставляет предметы на обочине, ответственность за их вывоз несет владелец. Если житель получает счет за коммунальные услуги от города Роли, город может взимать плату за специальный сбор груза.Если житель не получит счет за коммунальные услуги от города Роли, для вывоза предметов потребуется частный перевозчик.

Предметы, никогда не собираемые городом

Следующие предметы ни в коем случае нельзя класть для сбора у обочины — городские власти их не заберут:

• Шины
• Автозапчасти (бамперы, автомобильные двери и др.)
• Строительный мусор
• Ветви деревьев более 5 футов в длину или 6 дюймов в диаметре
• Пни
• Сыпучие листья
• Подрядные материалы

Не хотите ждать?

Если у вас есть вещь, от которой вы хотите избавиться, вы также можете отнести ее в пункт сдачи.

Коллекция материнской нагрузки — яркость

КОЛЛЕКЦИЯ МАТЕРИНСКОЙ НАГРУЗКИ

Не беспокойтесь, простой способ держать малышек в форме верха. В этот набор входят пять сумок-организаторов Mother Load — сумка для подгузников, сумка для чистой одежды, сумка для влажных вещей, сумка для закусок и сумка для игрушек. Считайте это своей подспорьем в дороге — способ сохранить чистую пару одежды, водостойкий мешок для белья для грязных и дополнительные подгузники во время выполнения поручений в течение всего дня, в поездке или для ухода за детьми в детском саду. или няня.Хранение закусок и игрушек организовано и их легко взять с собой для вашего малыша, когда вы не дома, что делает этот набор универсальным набором для любой новой мамы.

Коллекция Mother Load включает 5 мешков:

• Подгузник — Включает мягкую подкладку для подгузников. Вмещает много подгузников, салфеток, кремов, присыпки или всего, что вам нужно для чистки клыка вашего ребенка в дороге. Размер 9,5 «x 13»
• Мокрый мешок — Для хранения грязных или мокрых вещей, тканевых подгузников, купальных костюмов или грязной одежды и нагрудников на улице, чтобы ваш мешок для подгузников оставался свежим и чистым.Размер 9,5 «x 13»
• Сумка для чистой одежды — Храните лишние комбинезоны, футболки, штаны, носки и многое другое на всякий случай вдали от дома.
• Сумка для закусок — Включает три эластичных сетчатых кармана спереди для хранения бутылок или мелких предметов. Упакуйте сумку для закусок посудой, ковриками, нагрудниками, бутылками, закусками и многим другим. Все, что вам нужно, чтобы кормить малыша животом в дороге или на обеде с семьей. Размер 9,5 «x 13»
• ToyBag — Отлично подходит для игрушек, погремушек, детских книжек и всех его или ее любимых маленьких игрушек.Кроме того, по мере того, как малыши становятся старше, разрешите им собирать свои собственные сумки, что даст им независимость и контроль над игрушками во время поездки или прогулки. Размер 8,5 дюйма x 11 дюймов x 0,25 дюйма

ОСНОВНЫЕ ХАРАКТЕРИСТИКИ МАТЕРИНСКОЙ НАГРУЗКИ:

Mother Load можно стирать в машине, они прочные, многоразовые и легкие.

• Изготовлен из высококачественных материалов
• длится не только в младенческом возрасте
• Без ужасного химического запаха
• Рабочие ткани на долгие годы использования
• Застежка-молния не сломана
• Водостойкий очищаемый внешний слой
• Водонепроницаемая подкладка
• Без ПВХ, без бисфенола А, без свинца

Служба вывоза мусора с ожиданием и загрузкой, Великобритания

Если у вас нет места для пропуска или если доступ слишком ограничен для его доставки, позвоните в SafeGroup.Наши более компактные и маневренные автомобили будут собирать ваши отходы из любого места и избавят вас от необходимости использовать ресурсы для вывоза их за пределы вашего помещения

Если вам нужно утилизировать ограниченный объем мусора или если вы не уверены, какой размер следует заказывать, вы рискуете заплатить за пустое пространство, а не за сбор мусора. Наша служба ожидания и погрузки адаптирует сбор мусора к вашим потребностям.

Скипы — большая причина споров соседей.На оживленной торговой улице или в зонах общего доступа это может стать большой проблемой. Подождите и загрузите мусор, который решит эту проблему.

Пропуск не может быть одновременно более чем в одном месте. Но с вывозом мусора и загрузкой мы можем управлять коллекциями в разных точках на одном сайте или на нескольких адресах настолько гибко, насколько это необходимо.

Многим профессионалам, таким как слесари и специалисты по ремонту, не разрешается роскошь ждать наполнения бака и собирать дождь.Им нужно оперативно вывозить отходы с территории.

Список элементов, которые нельзя пропустить, часто бывает длинным и запутанным. Два примера — электрические и опасные отходы. SafeGroup wait and load обслуживает все потоки отходов без исключения.

Самосвалы-мухи, как и соседи, любят сбрасывать мусор в контейнеры. SafeGroup ждет и загружает сбор мусора для одного клиента — для вас.Не все сообщество.

Хорошие компании гордятся тем, что поступают правильно и производят впечатление. Skips не делают ничего, чтобы произвести впечатление на клиентов тем, как выглядит бизнес. Используйте SafeGroup, подождите, загрузите и почувствуйте любовь.

Мы удалим ваши отходы быстро и безопасно без дополнительных затрат, таких как плата за пропущенные лицензии.Сделайте один звонок, дата и время получения согласованы, оплата произведена, и работа сделана.

Служба вывоза мусора «ожидание и загрузка» дает бизнесу или домовладельцу большую уверенность, контроль и гибкость в отношении управления отходами, не подвергая их дополнительным рискам, которые могут возникнуть из-за пропусков.

Узнайте больше об услуге SafeGroup по вывозу мусора. Свяжитесь с нашей дружной командой экспертов по отходам сегодня: 0800 6687 1268

методов загрузки отношений — SQLAlchemy 1.4 Документация

Большая часть SQLAlchemy предоставляет широкий диапазон контроля над тем, как связаны объекты загружаются при запросе. Под «связанными объектами» мы понимаем коллекции. или скалярные ассоциации, настроенные на преобразователе с использованием отношения () . Это поведение можно настроить во время построения маппера с помощью Отношение . Ленивый параметр для отношения () функции, а также с помощью параметров с объектом Query .

Загрузка отношений делится на три категории; ленивая загрузка, нетерпеливо загрузка и нет загрузка.Ленивая загрузка относится к возвращаемым объектам из запроса без связанных объекты загружаются первыми. Когда данная коллекция или ссылка первый доступ к конкретному объекту, дополнительный оператор SELECT испускается так, что запрошенная коллекция загружается.

Активная загрузка относится к объектам, возвращаемым из запроса с соответствующими коллекция или скалярная ссылка уже загружены заранее. Запрос достигает этого либо путем дополнения оператора SELECT, который обычно emit с JOIN для одновременной загрузки в связанных строках, или путем испускания дополнительные операторы SELECT после основного для загрузки коллекций или скалярные ссылки сразу.

«Нет» загрузки относится к отключению загрузки для данного отношения, либо что атрибут пуст и просто никогда не загружается, или что он вызывает ошибка при обращении к нему, чтобы защититься от нежелательной ленивой загрузки.

Основные формы загрузки отношений:

• отложенная загрузка — доступно через lazy = 'select' или lazyload () вариант, это форма загрузки, которая генерирует оператор SELECT в время доступа к атрибуту для ленивой загрузки связанной ссылки на один объект за раз.Ленивая загрузка подробно описана в разделе Ленивая загрузка.

• объединенная загрузка — доступна через lazy = 'connected' или connectedload () опция, эта форма загрузки применяет JOIN к данному оператору SELECT так что связанные строки загружаются в один и тот же набор результатов. Присоединился к активной загрузке подробно описано в Совместной нетерпеливой загрузке.

• загрузка подзапроса — доступно через lazy = 'subquery' или subqueryload () опция, эта форма загрузки испускает второй оператор SELECT, который повторно устанавливает исходный запрос, встроенный в подзапрос, затем присоединяется к этому подзапросу связанная таблица, которая будет загружена для загрузки всех членов связанных коллекций / скаляров ссылки сразу.Активная загрузка подзапроса подробно описана в разделе Активная загрузка подзапроса.

• select IN loading — доступно через lazy = 'selectin' или selectinload () опция, эта форма загрузки испускает второй (или более) оператор SELECT, который собирает идентификаторы первичного ключа родительских объектов в предложение IN, так что все элементы связанных коллекций / скалярных ссылок загружаются одновременно по первичному ключу. Выбор загрузки IN подробно описан в разделе Выбор загрузки IN.

• поднять загрузку — доступно через lazy = 'raise' , lazy = 'raise_on_sql' , или опция raiseload () , эта форма загрузки запускается при в то же время обычно происходит ленивая загрузка, за исключением того, что она вызывает исключение ORM чтобы предотвратить нежелательную ленивую загрузку приложением. Введение в поднять загрузку находится в разделе Предотвращение нежелательной ленивой загрузки с помощью raiseload.

• без загрузки — доступно через lazy = 'noload' или noload () вариант; этот стиль загрузки превращает атрибут в пустой атрибут ( Нет или [] ), которые никогда не будут загружаться или иметь какой-либо эффект загрузки.Этот редко используемая стратегия ведет себя как нетерпеливый загрузчик, когда объекты загружен в том, что помещается пустой атрибут или коллекция, но для просроченного объекты полагаются на значение по умолчанию атрибута, возвращаемого на доступ; чистый эффект тот же, за исключением того, имя появляется в коллекции InstanceState.unloaded . без нагрузки может быть полезно для реализации атрибута «только для записи», но это не в настоящее время протестировано или официально поддерживается.

Настройка стратегий загрузчика во время сопоставления

Стратегия загрузчика для конкретного отношения может быть настроена во время отображения, чтобы иметь место во всех случаях, когда объект отображаемого Тип загружается при отсутствии каких-либо параметров уровня запроса, которые его изменяют. Это настраивается с помощью параметра отношения . Ленивый для отношения () ; общие значения для этого параметра включить выбрать , присоединиться к , подзапрос и выбрать в .

Например, чтобы настроить отношение для использования объединенной активной загрузки, когда запрашивается родительский объект:

 класс Родитель (Базовый):
    __tablename__ = 'родитель'

    id = столбец (целое число, primary_key = True)
    children = Relations ("Ребенок", ленивый = 'присоединился') 

Выше, всякий раз, когда загружается коллекция из родительских объектов , каждый Родительский также будет заполнять свою коллекцию дочерних элементов , используя строк, полученных путем добавления JOIN к запросу для объектов Parent .Информацию об этом стиле загрузки см. В разделе «Совместная активная загрузка».

Значение по умолчанию для аргумента отношения . Ленивый — «выберите» , что указывает на отложенную загрузку. См. «Ленивая загрузка» для дальнейший фон.

Загрузка отношений с опциями загрузчика

Другой и, возможно, более распространенный способ настройки стратегий загрузки состоит в том, чтобы настроить их для каждого запроса на основе определенных атрибутов с помощью Query.options () метод.Очень подробно управление загрузкой отношений доступно с помощью опций загрузчика; наиболее распространены объединились () , subqueryload () , selectinload () и lazyload () . Вариант принимает либо строковое имя атрибута по отношению к родителю или для большей конкретности может напрямую содержать атрибут, связанный с классом:

 # установить для детей ленивую загрузку
session.query (Родитель) .options (lazyload (Parent.children)). all ()

# установить дочерние элементы для быстрой загрузки с помощью соединения
сеанс.query (Parent) .options (connectedload (Parent.children)). all () 

Опции загрузчика также могут быть «связаны» с использованием цепочки методов чтобы указать, как должна происходить загрузка на следующих уровнях:

 session.query (Parent) .options (
    connectedload (Parent.children).
    подзапрос (Child.subelements)). all () 

Параметры связанного загрузчика могут применяться к «ленивой» загружаемой коллекции. Это означает, что когда коллекция или ассоциация лениво загружаются в доступ, после этого вступит в силу указанный параметр:

 сеанс.запрос (Родитель) .options (
    ленивый (Parent.children).
    подзапрос (Child.subelements)). all () 

Выше запрос вернет родительских объектов без дочерних объектов коллекции загружены. Когда детей коллекции на конкретном При первом обращении к родительскому объекту выполняется ленивая загрузка связанных объекты, но дополнительно применить активную загрузку к подэлементам сбор на каждого члена детей .

Приведенные выше примеры, использующие запрос , теперь называются 1.запросы в стиле x. Система опций также доступна для Запросы в стиле 2.0 с использованием метода Select.options () :

 stmt = select (Родительский) .options (
      ленивый (Parent.children).
      подзапрос (Child.subelements))

результат = session.execute (stmt) 

Под капотом Запрос в конечном итоге использует вышеуказанный выберите механизм на основе .

Добавление критериев к параметрам загрузчика

Атрибуты взаимосвязи, используемые для указания опций загрузчика, включают возможность добавления дополнительных критериев фильтрации в предложение ON соединения который был создан, или в соответствии с критериями WHERE, в зависимости от загрузчика стратегия.Это может быть достигнуто с помощью PropComparator.and_ () метод, который будет передавать параметр, так что загруженные результаты ограничены по заданным критериям фильтра:

 session.query (A) .options (lazyload (A.bs.and_ (B.id> 5))) 

При использовании ограничивающих критериев, если определенная коллекция уже загружена он не будет обновлен; чтобы обеспечить соблюдение новых критериев, примените параметр Query.populate_existing () :

 session.query (A) .options (lazyload (A.bs.and_ (B.id> 5))). populate_existing () 

Для добавления критериев фильтрации ко всем вхождениям объекта во всем запрос, независимо от стратегии загрузчика или от того, где он происходит при загрузке см. функцию with_loader_criteria () .

Указание дополнительных параметров с помощью Load.options ()

При использовании цепочки методов стиль загрузчика каждой ссылки в пути явно заявил. Для навигации по пути без изменения существующего стиля загрузчика конкретного атрибута может использоваться метод / функция defaultload () :

 сеанс.запрос (A) .options (
    defaultload (A.atob).
    connectedload (B.btoc)). all () 

Аналогичный подход можно использовать для одновременного указания нескольких подпараметров, используя метод Load.options () :

 session.query (A) .options (
    defaultload (A.atob) .options (
      объединенная загрузка (B.btoc),
      объединенная загрузка (B.btod)
    )). все () 

Примечание

Параметры загрузчика, применяемые к ленивой загрузке коллекций объекта. «привязаны» к конкретным экземплярам объекта, что означает, что они будут сохраняться при коллекциях, загруженных этим конкретным объектом, пока он существует в объем памяти.Например, в предыдущем примере:

 session.query (Parent) .options (
    ленивый (Parent.children).
    подзапрос (Child.subelements)). all () 

, если коллекция дочерних элементов на конкретном объекте Parent , загруженном срок действия указанного выше запроса истек (например, когда объект Session транзакция фиксируется или откатывается, или Session.expire_all () используется), при следующем доступе к коллекции Parent.children , чтобы перезагрузите его, Child.коллекция подэлементов снова будет загружена с использованием подзапрос активно загружается. Это остается так, даже если вышеупомянутый Родительский доступ к объекту осуществляется из последующего запроса, который указывает другой набор Чтобы изменить параметры существующего объекта, не удаляя его, и при повторной загрузке они должны быть установлены явно в сочетании с Query.populate_existing () метод:

 # изменить параметры родительских объектов, которые уже были загружены
session.query (родительский).populate_existing (). options (
    ленивый (Parent.children).
    lazyload (Child.subelements)). all () 

Если загруженные выше объекты полностью удалены из сеанса , например, из-за сборки мусора или Session.expunge_all () были использованы, «липкие» параметры также исчезнут, а вновь созданные объекты будут использовать новые параметры при повторной загрузке.

В будущем выпуске SQLAlchemy может быть добавлено больше альтернатив манипулированию параметры загрузчика для уже загруженных объектов.

Ленивая загрузка

По умолчанию все межобъектные отношения ленивая загрузка . Скаляр или атрибут коллекции, связанный с отношением () содержит триггер, который срабатывает при первом доступе к атрибуту. Этот триггер обычно выдает вызов SQL в точке доступа чтобы загрузить связанный объект или объекты:

 >>> jack.addresses
 
 ВЫБРАТЬ
    address.id AS Address_id,
    address.email_address AS address_email_address,
    адреса.user_id AS address_user_id
С адресов
КУДА ? = address.user_id
[5]
 
 [<Адрес (u'[email protected] ')>, <Адрес (u'[email protected]')>] 

Единственный случай, когда SQL не генерируется, — это простое отношение «многие к одному», когда связанный объект может быть идентифицирован только по его первичному ключу, и этот объект уже присутствует в текущей Сессии . По этой причине при ленивой загрузке может быть дорогостоящим для связанных коллекций, если одна из них загружает множество объектов с простыми значениями «многие-к-одному» против относительно небольшого набора возможные целевые объекты, отложенная загрузка может ссылаться на эти объекты локально без генерации такого количества операторов SELECT, сколько имеется родительских объектов.

Такое поведение по умолчанию «загрузка при доступе к атрибуту» известно как «ленивый» или Загрузка «select» — имя «select», потому что обычно выполняется инструкция «SELECT». при первом доступе к атрибуту.

Ленивая загрузка может быть включена для данного атрибута, который обычно настроен другим способом с использованием опции загрузчика lazyload () :

 из sqlalchemy.orm import lazyload

# принудительная отложенная загрузка для атрибута, для которого установлено значение
# обычно загружаем другим способом
сеанс.query (Пользователь) .options (lazyload (User.addresses)) 

Предотвращение нежелательной ленивой загрузки с помощью raiseload

Стратегия lazyload () дает один из самых общие проблемы, упомянутые в объектно-реляционном отображении; в N плюс одна проблема, в которой говорится, что для любых загруженных N объектов доступ к их лениво загруженным атрибутам означает, что будет N + 1 SELECT Выпущенные заявления. В SQLAlchemy обычное решение проблемы N + 1 состоит в том, чтобы использовать его очень мощную систему нетерпеливой загрузки.Однако нетерпеливая загрузка требует, чтобы атрибуты, которые должны быть загружены, были указаны с Запрос вперед. Проблема кода, который может получить доступ к другим атрибутам которые загружались неохотно, где ленивая загрузка нежелательна, могут быть устраняется с помощью стратегии raiseload () ; эта стратегия загрузчика заменяет ленивую загрузку информативной ошибкой собрано:

 из sqlalchemy.orm импорт поднять загрузку
session.query (Пользователь) .options (raiseload (Пользователь.адресов)) 

Выше объект User , загруженный из вышеуказанного запроса, не будет иметь загружена коллекция . адресов ; если какой-то код позже попытается доступ к этому атрибуту вызывает исключение ORM.

raiseload () может использоваться с так называемым спецификатором «подстановочного знака», чтобы указывают, что все отношения должны использовать эту стратегию. Например, чтобы настроить только один атрибут как активную загрузку, а все остальные как поднять:

 session.query (Заказ).параметры(
    connectedload (Order.items), raiseload ('*')) 

Вышеупомянутый подстановочный знак будет применяться к всем отношениям , а не только к заказу кроме предметов , но и все те, что на предметах Предмет . Установить raiseload () только для объектов Order , укажите полный путь с нагрузкой :

 из sqlalchemy.orm import Load

session.query (Порядок) .options (
    connectedload (Order.items), Load (Заказ) .raiseload ('*')) 

И наоборот, чтобы установить прибавку только для Item объектов:

 сеанс.запрос (Порядок) .options (
    connectedload (Order.items) .raiseload ('*')) 

Параметр raiseload () применяется только к атрибутам отношения. Для столбцов, опция defer () поддерживает defer.raiseload вариант, который работает таким же образом.

Изменено в версии 1.4.0: Стратегии «поднять загрузку» не выполняются в процессе промывки единицы работы, начиная с SQLAlchemy 1.4.0. Это означает что если единица работы должна загрузить определенный атрибут, чтобы завершите свою работу, он будет выполнять нагрузку.Не всегда легко предотвратить определенная нагрузка отношений, возникающая в процессе UOW особенно с менее распространенными типами отношений. Случай с ленивым = «поднять» больше предназначен для явного доступа к атрибутам в пространстве приложения.

Присоединился к нетерпеливой загрузке

Объединенная активная загрузка — это наиболее фундаментальный стиль активной загрузки в ORM. Он работает путем подключения JOIN (по умолчанию соединение LEFT OUTER) с оператором SELECT, созданным запросом и заполняет целевой скаляр / коллекцию из тот же набор результатов, что и у родителя.

На уровне сопоставления это выглядит так:

 Адрес (База):
    # ...

    user = Relationship (Пользователь, ленивый = "присоединился") 

Присоединенная активная загрузка обычно применяется как опция к запросу, а не в качестве варианта загрузки по умолчанию для сопоставления, в частности, когда используется для коллекции, а не ссылки «многие к одному». Это достигается с использованием опции загрузчика connectedload () :

 >>> jack = session.query (Пользователь). \
... варианты (connectedload (User.адреса)). \
... filter_by (имя = 'jack'). all ()
 
 ВЫБРАТЬ
    address_1.id AS address_1_id,
    address_1.email_address AS address_1_email_address,
    address_1.user_id AS address_1_user_id,
    users.id AS идентификатор_пользователя, имя_пользователя AS имя_пользователя,
    users.fullname AS users_fullname,
    users.nickname AS имя_пользователя
ОТ пользователей
LEFT OUTER JOIN адреса AS address_1
    ВКЛ. Users.id = address_1.user_id
ГДЕ users.name =?
['Джек']
 
 

JOIN, генерируемый по умолчанию, является LEFT OUTER JOIN, чтобы разрешить ведущий объект это не относится к связанной строке.Для атрибута, который гарантирован иметь элемент, такой как многие-к-одному ссылка на связанный объект, где ссылочный внешний ключ НЕ ПУСТО, запрос можно сделать более эффективным, используя внутреннее соединение; это доступно на уровне сопоставления через отношение . innerjoin флаг :

 Адрес (База):
    # ...

    user_id = Столбец (ForeignKey ('users.id'), nullable = False)
    user = Relationship (Пользователь, ленивый = "присоединился", innerjoin = True) 

На уровне параметров запроса через объединенную загрузку .флаг innerjoin :

 session.query (Адрес) .options (
    connectedload (Address.user, innerjoin = True)) 

JOIN будет размещаться справа при применении в цепочке, которая включает ВНЕШНЕЕ СОЕДИНЕНИЕ:

 >>> session.query (Пользователь) .options (
... connectedload (User.addresses).
... connectedload (Address.widgets, innerjoin = True)). all ()
 
 ВЫБРАТЬ
    widgets_1.id AS widgets_1_id,
    widgets_1.name AS widgets_1_name,
    address_1.id AS address_1_id,
    адреса_1.email_address AS address_1_email_address,
    address_1.user_id AS address_1_user_id,
    users.id AS идентификатор_пользователя, имя_пользователя AS имя_пользователя,
    users.fullname AS users_fullname,
    users.nickname AS имя_пользователя
ОТ пользователей
ЛЕВОЕ ВНЕШНЕЕ СОЕДИНЕНИЕ (
    адреса AS address_1 ПРИСОЕДИНЯЙТЕСЬ к виджетам AS widgets_1 ON
    address_1.widget_id = widgets_1.id
) ВКЛ. Users.id = address_1.user_id
 
 

В более старых версиях SQLite указанное выше вложенное правое соединение JOIN может быть повторно отображено. как вложенный подзапрос.Более старые версии SQLAlchemy преобразовывали бы вложенные справа во всех случаях присоединяется к подзапросам.

Предупреждение

Использование with_for_update в контексте активной загрузки отношения официально не поддерживаются и не рекомендуются SQLAlchemy и может не работать с определенными запросами на различных бэкэнды базы данных. При успешном использовании with_for_update с запросом, который включает connectedload () , SQLAlchemy будет попытаться сгенерировать SQL, который блокирует все задействованные таблицы.

Объединенная активная загрузка и пакетирование набора результатов

Центральная концепция совместной активной загрузки применительно к коллекциям заключается в том, что объект Query должен исключить дубликаты строк в начале запрашиваемый объект. Как указано выше, если загруженный нами объект User ссылается на три объекта Address , то результат оператора SQL имел бы три строки; еще Запрос возвращает только один объект User . Поскольку дополнительные строки получены для Пользовательский объект только что загружен в предыдущей строке, дополнительные столбцы, которые см. новый адрес Объекты направляются в дополнительные результаты в пределах Пользователь .обращается к коллекции этого конкретного объекта.

Этот процесс очень прозрачен, однако подразумевает, что загрузка несовместима с «пакетными» результатами запроса, предоставленными Query.yield_per () , когда используется для загрузки коллекции. Присоединился жадная загрузка, используемая для скалярных ссылок, однако совместима с Query.yield_per () . Результатом метода Query.yield_per () в исключении, создаваемом, если объединенный нетерпеливый загрузчик на основе коллекции в игре.

Для «пакетной обработки» запросов с произвольно большими наборами данных результатов при сохранении совместимость с объединенной активной загрузкой на основе коллекций, выдача нескольких Операторы SELECT, каждая из которых относится к подмножеству строк с помощью WHERE пункт, например окна. В качестве альтернативы рассмотрите возможность использования активной загрузки «select IN». который потенциально совместим с Query.yield_per () , при условии что используемый драйвер базы данных поддерживает несколько одновременных курсоров (Драйверы SQLite, PostgreSQL, а не драйверы MySQL или ODBC для SQL Server).

Дзен совместной нетерпеливой загрузки

Поскольку объединенная активная загрузка, похоже, имеет много общего с использованием Query.join () , он часто вызывает путаницу относительно того, когда и как следует использоваться. Очень важно понимать разницу между тем, что Query.join () используется для изменения результатов запроса, joinload () проходит через большие длины до , а не , изменяет результаты запроса, и вместо этого скрыть эффекты визуализированного соединения, чтобы разрешить только связанные объекты присутствовать.

Философия, лежащая в основе стратегий загрузчика, заключается в том, что любой набор схем загрузки может быть применен к определенному запросу, и результаты не изменят — только количество операторов SQL, необходимых для полной загрузки связанных объектов и коллекций изменения. Конкретный запрос может начинаться с использования всех отложенных загрузок. После использования в контексте может быть обнаружено, что определенные атрибуты или коллекции всегда доступны, и что было бы эффективнее сменить загрузчик стратегия для них.Стратегия может быть изменена без каких-либо других модификаций. к запросу, результаты останутся идентичными, но будет меньше операторов SQL. быть испущенным. Теоретически (и в значительной степени на практике) вы ничего не можете сделать с Запрос заставит его загрузить другой набор основных или связанных объекты на основе изменения стратегии загрузчика.

Как joinload () , в частности, достигает этого результата, не влияя на строки объекта, возвращаемые каким-либо образом, заключаются в том, что он создает анонимный псевдоним присоединяется к вашему запросу, поэтому на них не могут ссылаться другие части запрос.Например, в приведенном ниже запросе используется connectedload () для создания LEFT OUTER JOIN от пользователей с до адресов , однако добавлен ORDER BY против Address.email_address недействителен — объект Address не является названо в запросе:

 >>> jack = session.query (Пользователь). \
... параметры (объединенная загрузка (Адреса пользователей)). \
... фильтр (User.name == 'jack'). \
... order_by (Address.email_address) .all ()
 
 ВЫБРАТЬ
    адреса_1.id AS address_1_id,
    address_1.email_address AS address_1_email_address,
    address_1.user_id AS address_1_user_id,
    users.id AS users_id,
    users.name AS имя_пользователя,
    users.fullname AS users_fullname,
    users.nickname AS имя_пользователя
ОТ пользователей
LEFT OUTER JOIN адреса AS address_1
    ВКЛ. Users.id = address_1.user_id
ГДЕ users.name =?
ЗАКАЗАТЬ ПО address.email_address <- это неверная часть!
['Джек']
 
 

Выше, ORDER BY address.email_address недействителен, так как адресов не входят в ИЗ списка.Правильный способ загрузки записей пользователя и заказа по электронной почте адрес должен использовать Query.join () :

 >>> jack = session.query (Пользователь). \
... присоединиться (User.addresses). \
... фильтр (User.name == 'jack'). \
... order_by (Address.email_address) .all ()
 
 ВЫБРАТЬ
    users.id AS users_id,
    users.name AS имя_пользователя,
    users.fullname AS users_fullname,
    users.nickname AS имя_пользователя
ОТ пользователей
ПРИСОЕДИНЯЙТЕСЬ к адресам НА users.id = addresses.user_id
ГДЕ users.name =?
ЗАКАЗАТЬ ПО адресам.адрес электронной почты
['Джек']
 
 

Приведенное выше утверждение, конечно, не то же самое, что и предыдущее, в том, что столбцы из адресов вообще не включаются в результат. Мы можем добавить connectedload () снова, так что есть два соединения, одно из которых мы заказывают, другой используется анонимно для загрузки содержимого Адреса пользователей коллекция:

 >>> jack = session.query (Пользователь). \
... присоединиться (User.addresses). \
... options (connectedload (User.addresses)). \
... фильтр (User.name == 'jack'). \
... order_by (Address.email_address) .all ()
 
 ВЫБРАТЬ
    address_1.id AS address_1_id,
    address_1.email_address AS address_1_email_address,
    address_1.user_id AS address_1_user_id,
    users.id AS идентификатор_пользователя, имя_пользователя AS имя_пользователя,
    users.fullname AS users_fullname,
    users.nickname AS имя_пользователя
ОТ пользователей ПРИСОЕДИНЯЙТЕСЬ к адресам
    ВКЛ. Users.id = address.user_id
LEFT OUTER JOIN адреса AS address_1
    ПО пользователям.id = address_1.user_id
ГДЕ users.name =?
ЗАКАЗАТЬ ПО адресам.
['Джек']
 
 

Выше мы видим, что Query.join () используется для предоставления JOIN предложения, которые мы хотели бы использовать в последующем критерии запроса, тогда как наше использование connectedload () занимается только загрузкой User.addresses collection, для каждого User в результате. В этом случае, два соединения, скорее всего, кажутся избыточными — что так и есть.Если бы мы хотели используйте только один JOIN для загрузки коллекции, а также для упорядочивания, мы используем contains_eager () опция, описанная в разделе «Маршрутизация явных соединений / операторов в быстро загружаемые коллекции» ниже. Но чтобы понять, почему connectedload () делает то, что делает, рассмотрим, если бы мы фильтрация по определенному адресу :

 >>> jack = session.query (Пользователь). \
... присоединиться (User.addresses). \
... параметры (объединенная загрузка (Адреса пользователей)). \
... фильтр (User.name == 'jack'). \
... фильтр (Address.email_address == '[email protected]'). \
... все()
 
 ВЫБРАТЬ
    address_1.id AS address_1_id,
    address_1.email_address AS address_1_email_address,
    address_1.user_id AS address_1_user_id,
    users.id AS идентификатор_пользователя, имя_пользователя AS имя_пользователя,
    users.fullname AS users_fullname,
    users.nickname AS имя_пользователя
ОТ пользователей ПРИСОЕДИНЯЙТЕСЬ к адресам
    ВКЛ. Users.id = address.user_id
LEFT OUTER JOIN адреса AS address_1
    ПО users.id = address_1.ID пользователя
ГДЕ users.name =? И address.email_address =?
['jack', '[email protected]']
 
 

Выше мы видим, что у двух JOIN очень разные роли. Один будет соответствовать ровно одна строка, это из объединения Пользователь и Адрес , где Address.email_address=='[email protected] '. Другой LEFT OUTER JOIN будет соответствовать всем адресам строкам, относящимся к пользователю , и используется только для заполните пользователя .обращается к коллекции для тех объектов User , которые вернулся.

Изменяя использование connectedload () на другой стиль загрузки, мы может изменить способ загрузки коллекции полностью независимо от SQL, используемого для получить фактические пользовательских строк, которые мы хотим. Ниже мы меняем connectedload () в подзапрос () :

 >>> jack = session.query (Пользователь). \
... присоединиться (User.addresses). \
... параметры (подзапрос (User.адреса)). \
... фильтр (User.name == 'jack'). \
... фильтр (Address.email_address == '[email protected]'). \
... все()
 
 ВЫБРАТЬ
    users.id AS users_id,
    users.name AS имя_пользователя,
    users.fullname AS users_fullname,
    users.nickname AS имя_пользователя
ОТ пользователей
ПРИСОЕДИНЯЙТЕСЬ к адресам НА users.id = addresses.user_id
КУДА
    users.name =?
    И address.email_address =?
['jack', '[email protected]']

# ... subqueryload () испускает SELECT по порядку
# загрузить все адресные записи ...
 
 

При использовании объединенной активной загрузки, если запрос содержит модификатор, влияющий на строки, возвращаемые извне в соединения, например, при использовании DISTINCT, LIMIT, OFFSET или аналогичный, завершенный оператор сначала помещается в подзапрос, и применяются объединения, используемые специально для объединенной активной загрузки в подзапрос.Совместная активная загрузка SQLAlchemy делает все возможное, и затем десять миль дальше, чтобы абсолютно гарантировать, что это не повлияет на конец результат запроса, только способ загрузки коллекций и связанных объектов, независимо от формата запроса.

Ожидается загрузка подзапроса

Активная загрузка подзапроса настраивается так же, как и присоединился к активной загрузке; для отношения . ленивый параметр , мы должны указать «подзапрос» , а не «соединенный» , а для опцию мы используем опцию subqueryload () , а не опцию connectedload () вариант.

Операция активной загрузки подзапроса заключается в выдаче второго оператора SELECT. для каждой загружаемой связи сразу для всех объектов результата. Этот оператор SELECT относится к исходному оператору SELECT в оболочке внутри подзапроса, так что мы получаем тот же список первичных ключей для возвращаемого первичного объекта, затем свяжите его с суммой всех участников коллекции, чтобы загрузить их сразу:

 >>> jack = session.query (Пользователь). \
... параметры (подзапрос (User.адреса)). \
... filter_by (имя = 'jack'). all ()
 
 ВЫБРАТЬ
    users.id AS users_id,
    users.name AS имя_пользователя,
    users.fullname AS users_fullname,
    users.nickname AS имя_пользователя
ОТ пользователей
ГДЕ users.name =?
('Джек',)
ВЫБРАТЬ
    address.id AS Address_id,
    address.email_address AS address_email_address,
    address.user_id AS address_user_id,
    anon_1.users_id КАК anon_1_users_id
ИЗ (
    ВЫБЕРИТЕ users.id AS users_id
    ОТ пользователей
    ГДЕ users.name =?) AS anon_1
JOIN адреса ON anon_1.users_id = address.user_id
ЗАКАЗАТЬ ПО anon_1.users_id, addresses.id
('Джек',)
 
 

Стратегия подзапроса имеет много преимуществ по сравнению с объединенной активной загрузкой. в зоне загрузки коллекций. Во-первых, он позволяет исходный запрос действовать, не меняя его вообще, не вводя, в частности, LEFT OUTER JOIN, что может сделать его менее эффективным. Во-вторых, это позволяет для быстрой загрузки многих коллекций без создания единого запроса в нем много JOIN, что может быть еще менее эффективным; каждое отношение загружается в полностью отдельный запрос.Наконец, поскольку дополнительный запрос нужно только загрузить элементы коллекции, а не ведущий объект, он может используйте внутренний JOIN во всех случаях для большей эффективности запросов.

К недостаткам подзапроса можно отнести сложность исходной запрос передается в запросы отношений, которые в сочетании с использование подзапроса, может в некоторых случаях на некоторых серверах (особенно в MySQL) создавать значительно медленные запросы. Кроме того, стратегия загрузки подзапросов может только загружать сразу полное содержимое всех коллекций, поэтому несовместимо с «пакетной» загрузкой, предоставляемой Query.yield_per () , оба для сбора и скалярные отношения.

Новый стиль загрузки, предоставляемый selectinload () , решает эти проблемы. ограничения subqueryload () .

Важность заказа

Запрос, который использует subqueryload () в сочетании с ограничивающий модификатор, такой как Query.first () , Query.limit () , или Query.offset () должен всегда включать Query.order_by () против уникальных столбцов, таких как первичный ключ, так что дополнительные запросы отправлено subqueryload () include тот же порядок, что и в родительском запросе. Без него есть шанс что внутренний запрос может вернуть неправильные строки:

 # неверно, нет ORDER BY
session.query (Пользователь) .options (
    subqueryload (User.addresses)). first ()

# неверно, если User.name не уникальное
session.query (Пользователь) .options (
    подзапрос (User.addresses)
) .order_by (Пользователь.имя()

# верный
session.query (Пользователь) .options (
    подзапрос (User.addresses)
) .order_by (Имя пользователя, Идентификатор пользователя) .first () 

Выбрать IN загрузка

Загрузка Select IN аналогична активной загрузке подзапроса, однако Выпущенный оператор SELECT имеет гораздо более простую структуру, чем у подзапрос ждет загрузки. В большинстве случаев загрузка selectin является наиболее простой и удобной. эффективный способ быстрой загрузки коллекций объектов. Единственный сценарий в какая загрузка с нетерпением selectin невозможна, когда модель использует составные первичные ключи, а внутренняя база данных не поддерживает кортежи с IN, который в настоящее время включает SQL Server.

Активная загрузка «Select IN» предоставляется с использованием аргумента «selectin» для Relationsy или с помощью загрузчика selectinload () вариант. Этот стиль загрузки испускает SELECT, который относится к первичному ключу. значения родительского объекта, или в случае многозначного отношения к дочерним объектам внутри предложения IN в порядок загрузки связанных ассоциаций:

 >>> jack = session.query (Пользователь). \
... варианты (selectinload (User.адреса)). \
... filter (or_ (User.name == 'jack', User.name == 'ed')). all ()
 
 ВЫБРАТЬ
    users.id AS users_id,
    users.name AS имя_пользователя,
    users.fullname AS users_fullname,
    users.nickname AS имя_пользователя
ОТ пользователей
ГДЕ users.name =? ИЛИ users.name =?
('Джек', 'Эд')
ВЫБРАТЬ
    address.id AS Address_id,
    address.email_address AS address_email_address,
    address.user_id AS address_user_id
С адресов
ГДЕ адреса. User_id IN (?,?)
(5, 7)
 
 

Выше второй SELECT относится к адресам.user_id IN (5, 7) , где «5» и «7» являются значениями первичного ключа для двух предыдущих Пользователь загруженные объекты; после полной загрузки пакета объектов их первичный ключевые значения вводятся в предложение IN для второго SELECT. Поскольку связь между пользователем и адресом имеет простую основное условие соединения и обеспечивает, что значения первичного ключа для Пользователь могут быть получены из Address.user_id , Оператор вообще не имеет соединений или подзапросов.

Изменено в версии 1.3: загрузка selectin может опускать JOIN для простого коллекция «один ко многим».

Для простых загрузок «многие к одному» JOIN также не требуется в качестве внешнего ключа. используется значение из родительского объекта:

 >>> session.query (Адрес). \
... параметры (selectinload (Address.user)). all ()
 
 ВЫБРАТЬ
    address.id AS Address_id,
    address.email_address AS address_email_address,
    address.user_id AS address_user_id
    С адресов
ВЫБРАТЬ
    пользователей.id AS users_id,
    users.name AS имя_пользователя,
    users.fullname AS users_fullname,
    users.nickname AS имя_пользователя
ОТ пользователей
ГДЕ users.id IN (?,?)
(1, 2)
 
 

Изменено в версии 1.3.6: загрузка selectin может также опускать JOIN для простого отношения «многие к одному».

Select IN также поддерживает отношения «многие-ко-многим», где в настоящее время СОЕДИНЯЕТСЯ со всеми тремя таблицами, чтобы сопоставить строки от одной стороны к другой.

Что нужно знать об этом виде загрузки:

• Оператор SELECT, генерируемый стратегией загрузчика selectin, в отличие от что «подзапрос», не требует подзапроса и не наследует никаких ограничений производительности исходного запроса; поиск представляет собой простой поиск по первичному ключу и должен имеют высокую производительность.

• Особые требования к порядку подзапроса, описанные на Важность заказа также не распространяется на загрузку selectin; селектин всегда связывается напрямую с родительским первичным ключом и не может вернуть неверный результат.

• Загрузка «selectin», в отличие от загрузки с объединенным запросом или подзапросом, всегда приводит к SELECT с точки зрения только что загруженных непосредственных родительских объектов, а не исходный тип объекта в верхней части цепочки. Итак, если вы хотите загрузить много уровней, загрузка «selectin» по-прежнему не потребует никаких JOIN для простых отношения «один ко многим» или «многие к одному».Для сравнения присоединились и загрузка подзапроса всегда относится к нескольким СОЕДИНЕНИЯМ до исходного родитель.

• Стратегия генерирует SELECT для до 500 значений родительского первичного ключа в время, поскольку первичные ключи преобразуются в большое выражение IN в Оператор SQL. Некоторые базы данных, такие как Oracle, имеют жесткие ограничения на размер выражение IN может быть, и общий размер строки SQL не должен быть сколь угодно большим.

• Поскольку загрузка «selectin» зависит от IN, для сопоставления с составным первичным ключи, он должен использовать форму «кортежа» IN, которая выглядит как WHERE (стол.столбец_a, таблица.столбец_b) IN ((?,?), (?,?), (?,?)) . Этот синтаксис в настоящее время не поддерживается на SQL Server, а для SQLite требуется как минимум версия 3.15.0 В SQLAlchemy нет специальной логики для проверки заранее, какие платформы поддерживают этот синтаксис или нет; если столкнуться с не поддерживающая платформа, база данных немедленно вернет ошибку. An Преимущество SQLAlchemy, просто запустившего SQL, чтобы он потерпел неудачу, состоит в том, что если конкретная база данных начинает поддерживать этот синтаксис, она будет работать без любые изменения в SQLAlchemy (как в случае с SQLite).

В общем, загрузка «selectin», вероятно, лучше активной загрузки «подзапроса». в большинстве случаев, за исключением требований синтаксиса с составными первичными ключами и, возможно, он может выдавать много операторов SELECT для больших наборов результатов. Как всегда, разработчикам следует потратить время на изучение утверждения и результаты, полученные от их приложений в разработке, чтобы проверьте, что все работает эффективно.

Какую нагрузку использовать?

Какой тип загрузки использовать обычно сводится к оптимизации компромисса между количеством выполнений SQL, сложностью сгенерированного SQL и количеством данные получены.Возьмем два примера, отношение () который ссылается на коллекцию, и отношение () , которое ссылается на скалярную ссылку «многие к одному».

• При использовании отложенной загрузки по умолчанию, если вы загружаете 100 объектов, а затем получаете доступ к коллекции на каждом из их, всего будет выпущен 101 оператор SQL, хотя каждый оператор обычно будет простой SELECT без каких-либо объединений.

• При использовании совместной загрузки загрузка 100 объектов и их коллекций выдаст только один SQL утверждение.Однако общее количество выбранных строк будет равно сумме размеров всех коллекций плюс один дополнительная строка для каждого родительского объекта, имеющего пустую коллекцию. Каждая строка также будет содержать полный набор столбцов, представленных родителями, повторяющийся для каждого элемента коллекции — SQLAlchemy не повторно получить эти столбцы, отличные от столбцов первичного ключа, однако большинство DBAPI (с некоторыми исключения) будет передавать полные данные каждого родителя по проводам в клиентское соединение в любой случай.Поэтому объединенная активная загрузка имеет смысл только тогда, когда размер коллекций относительно маленький. LEFT OUTER JOIN также может потребовать больших затрат производительности по сравнению с INNER JOIN.

• При использовании загрузки подзапроса загрузка 100 объектов будет испустить два оператора SQL. Второй оператор получит общее количество строк, равных сумме размеров всех коллекций. ВНУТРЕННЕЕ СОЕДИНЕНИЕ — это используется, и запрашивается минимум родительских столбцов, только первичные ключи. Таким образом, загрузка подзапроса имеет смысл, когда коллекции больше.

• Когда несколько уровней глубины используются при загрузке соединения или подзапроса, загрузка коллекций внутри- collection умножит общее количество строк, выбранных декартово. Оба join и подзапрос с нетерпеливой загрузкой всегда присоединяются к исходному родительскому классу; при загрузке коллекции на четыре уровня в глубину будет четыре соединения с родителем. загрузка selectin с другой стороны, всегда будет ровно одно СОЕДИНЕНИЕ к немедленному родительская таблица.

• Используя загрузку selectin, загрузка 100 объектов также выдаст два SQL операторов, второй из которых относится к 100 первичным ключам объекты загружены.при загрузке selectin будет отображаться не более 500 первичных ключевые значения в один оператор SELECT; так что для сбора свинца больше чем 500, для каждого пакета Выбрано 500 объектов.

• Использование нескольких уровней глубины с загрузкой selectin не влечет за собой «Декартова» проблема, которая объединилась, и подзапрос, ожидающий загрузки; запросы для загрузки selectin имеют лучшие рабочие характеристики и наименьшее количество строк. Единственное предостережение: их может быть больше, чем один SELECT, испускаемый в зависимости от размера результата лида.

• загрузка selectin, в отличие от объединенного (при использовании коллекций) и подзапроса загрузка (все виды отношений) потенциально совместима с результатом установить пакетирование, обеспечиваемое Query.yield_per () , предполагая, что драйвер базы данных, поэтому может разрешить пакетную обработку для больших наборов результатов.

• При использовании ленивой загрузки по умолчанию загрузка 100 объектов понравится в случае коллекции испускает до 101 оператора SQL.Однако из этого правила есть существенное исключение. если ссылка «многие к одному» является простой ссылкой внешнего ключа на первичный ключ цели, каждая ссылка будет проверена первой в текущей карте идентичности с помощью Query.get () . Так вот, если коллекция объектов ссылается на относительно небольшой набор целевых объектов или на полный набор возможных целевых объектов уже загружены в сеанс и на них есть сильные ссылки, использование значения по умолчанию lazy = ’select’ , безусловно, является наиболее эффективным способом.

• При использовании совместной загрузки загрузка 100 объектов вызовет только один оператор SQL. Соединение будет LEFT OUTER JOIN, и общее количество строк будет равно 100 во всех случаях. Если вы знаете, что у каждого родителя обязательно есть ребенок (т. Е. Иностранный ссылка на ключ НЕ ПУСТО), объединенная нагрузка может быть настроена с помощью Relationship.innerjoin установлен на True , что является обычно указывается в отношении () . Для загрузки объектов, где есть много возможных целевых ссылок, которые, возможно, еще не были загружены, совместная загрузка с INNER JOIN чрезвычайно эффективен.

• Загрузка подзапроса вызовет вторую загрузку для всех дочерних объектов, поэтому для загрузки 100 объектов было бы испущено два оператора SQL. Вероятно, здесь не так много преимуществ перед однако с присоединенной загрузкой, за исключением, возможно, того, что загрузка подзапроса может использовать ВНУТРЕННЕЕ СОЕДИНЕНИЕ во всех случаях тогда как объединенная загрузка требует, чтобы внешний ключ НЕ был NULL.

• Загрузка Selectin также вызовет вторую загрузку для всех дочерних объектов (и как указано ранее, для больших результатов он будет выдавать SELECT на 500 строк), поэтому для загрузки 100 объектов было бы испущено два оператора SQL.Сам запрос по-прежнему должен ПРИСОЕДИНЯЙТЕСЬ к родительской таблице, чтобы загрузка selectin для много-к-одному против совместной активной загрузки, за исключением использование INNER JOIN во всех случаях.

Полиморфная нетерпеливая загрузка

Поддерживается спецификация полиморфных опций для каждой загрузки. Примеры см. В разделе «Активная загрузка определенных или полиморфных подтипов». метода PropComparator.of_type () в сочетании с with_polymorphic () функция.

Стратегии загрузки подстановочных знаков

Каждый из connectedload () , subqueryload () , lazyload () , selectinload () , noload () и raiseload () могут использоваться для установки значения по умолчанию. стиль отношения () загрузка для конкретного запроса, затрагивающего все отношения () -сопоставление атрибуты не иначе указано в запросе . Эта функция доступна при прохождении строка '*' в качестве аргумента любой из этих опций:

 сеанс.запрос (MyClass) .options (lazyload ('*')) 

Выше параметр lazyload ('*') заменит параметр lazyload ('*') из всех конструкций Relationship () , используемых для этого запроса, за исключением тех, которые используют «динамический» стиль загрузки . Если в некоторых отношениях указано lazy = 'объединил' или lazy = 'subquery' , например, используя lazyload ('*') будет в одностороннем порядке заставить все эти отношения использовать 'select' loading, e.грамм. испустить Оператор SELECT при доступе к каждому атрибуту.

Опция не заменяет опции загрузчика, указанные в запрос, например eagerload () , subqueryload () и т. Д. В запросе ниже по-прежнему будет использоваться объединенная загрузка. для виджета отношение:

 session.query (MyClass) .options (
    ленивая загрузка ('*'),
    connectedload (MyClass.widget)
) 

Если передано несколько опций '*' , последняя имеет приоритет над те, которые ранее прошли.

Стратегии загрузки подстановочных знаков для отдельных объектов

Вариантом стратегии загрузчика подстановочных знаков является возможность установки стратегии на индивидуальной основе. Например, при запросе пользователя и адреса , мы можем проинструктировать все отношения на адресе только для использования ленивой загрузки сначала применив объект Load , а затем указав * как прикованный вариант:

 session.query (Пользователь, Адрес) .options (
    Загрузить (Адрес).ленивая загрузка ('*')) 

Выше для всех отношений по адресу Адрес будет установлена ​​отложенная загрузка.

Маршрутизация явных соединений / операторов в быстро загружаемые коллекции

Поведение connectedload () таково, что соединения создается автоматически с использованием анонимных псевдонимов в качестве целей, результаты которых направляются в коллекции и скалярные ссылки на загруженные объекты. Часто бывает, что запрос уже включает необходимые объединения, которые представляют конкретную коллекцию или скаляр ссылка, а объединения, добавленные функцией объединенной загрузки, являются избыточными, но пока вы по-прежнему хотите, чтобы коллекции / ссылки были заполнены.

Для этого SQLAlchemy предоставляет contains_eager () вариант. Эта опция используется так же, как и connectedload () , за исключением того, что предполагается, что Запрос укажет соответствующие соединения явно. Ниже мы указываем соединение между User и Address и дополнительно установить это как основу для активной загрузки адресов пользователей :

 класс Пользователь (Базовый):
    __tablename__ = 'пользователь'
    id = столбец (целое число, primary_key = True)
    адреса = отношения ("Адрес")

Адрес класса (База):
    __tablename__ = 'адрес'

    #...

q = session.query (Пользователь) .join (User.addresses). \
            options (contains_eager (User.addresses)) 

Если часть выражения «нетерпеливо» имеет псевдоним, путь должен быть указан с помощью PropComparator.of_type () , что позволяет конкретная конструкция aliased () , которую необходимо передать:

 # использовать псевдоним объекта Address
adalias = aliased (Адрес)

# создать объект Query, ожидающий результатов "адресов"
query = session.query (Пользователь). \
    externaljoin (Пользователь.address.of_type (adalias)). \
    параметры (contains_eager (User.addresses.of_type (adalias)))

# получить результаты нормально
r = query.all ()
 
 ВЫБРАТЬ
    users.user_id AS users_user_id,
    users.user_name AS users_user_name,
    adalias.address_id AS adalias_address_id,
    adalias.user_id AS adalias_user_id,
    adalias.email_address AS adalias_email_address,
    (... другие столбцы ...)
ОТ пользователей
ЛЕВОЕ ВНЕШНЕЕ СОЕДИНЕНИЕ email_addresses AS email_addresses_1
ВКЛ. Users.user_id = email_addresses_1.user_id
 
 

Путь, указанный в качестве аргумента для contains_eager () требует быть полным путем от начальной сущности.Например, если мы загружали Users-> orders-> Order-> items-> Item , параметр будет использоваться как:

 запрос (Пользователь) .options (
    contains_eager (User.orders).
    contains_eager (Order.items)) 

Использование contains_eager () для загрузки результата пользовательской фильтрации

Когда мы используем contains_eager () , , мы сами конструируем SQL, который будет использоваться для заполнения коллекций. Отсюда естественно следует что мы можем выбрать изменить , какие значения предназначена для хранения коллекции, написав наш SQL для загрузки подмножества элементов для коллекций или скалярные атрибуты.

В качестве примера мы можем загрузить объект User и с нетерпением загрузить только определенные адресов в свою коллекцию . адресов путем фильтрации объединенных данных, маршрутизация с использованием contains_eager () , также с использованием Query.populate_existing () для проверки всех уже загруженных коллекций перезаписываются:

 q = session.query (Пользователь). \
        присоединиться (User.addresses). \
        filter (Address.email_address.like ('% @ aol.com')). \
        параметры (contains_eager (User.адреса)). \
        populate_existing () 

Приведенный выше запрос загрузит только объекты User , которые содержат минимум Адрес объекта , который содержит подстроку 'aol.com' в своем электронная почта поле; коллекция User.addresses будет содержать только эти записи адреса , и , а не , любые другие записи адреса , собственно связано с коллекцией.

Подсказка

Во всех случаях ORM SQLAlchemy не перезаписывает уже загруженный атрибуты и коллекции , если не указано иное.Поскольку есть карта идентичности, часто бывает, что запрос ORM возвращение объектов, которые на самом деле уже присутствовали и были загружены в память. Следовательно, при использовании contains_eager () для заполнения коллекции в качестве альтернативы обычно рекомендуется использовать Query.populate_existing () , как показано выше, так что уже загруженная коллекция обновляется новыми данными. Query.populate_existing () сбросит все атрибуты , которые были уже присутствует, включая ожидающие изменения, поэтому убедитесь, что все данные сброшены перед его использованием.Использование Session с его поведением по умолчанию автозапуска достаточно.

Примечание

Настроенная коллекция, которую мы загружаем с помощью contains_eager () не «липкий»; то есть при следующей загрузке этой коллекции она будет быть загруженным с обычным содержимым по умолчанию. Коллекция подлежит для перезагрузки, если срок действия объекта истек, что происходит всякий раз, когда Session.commit () , Session.rollback () Используются методы предполагая настройки сеанса по умолчанию, или Session.expire_all () или Session.expire () методов.

Создание пользовательских правил загрузки

Глубокая алхимия

Это продвинутая техника! Отличный уход и тестирование следует применять.

ORM имеет различные граничные случаи, когда значение атрибута локально доступен, однако сам ORM не знает об этом. Там также бывают случаи, когда желательна определяемая пользователем система атрибутов загрузки. Для поддержки варианта использования определяемых пользователем систем загрузки ключевая функция Предоставляется set_committed_value () .Эта функция в основном эквивалентно собственной функции Python setattr () , за исключением того, что при применении к целевому объекту система «истории атрибутов» SQLAlchemy который используется для определения того, что изменения времени промывки пропущены; атрибут назначается таким же образом, как если бы ORM загрузил его таким образом из базы данных.

Использование set_committed_value () можно комбинировать с другим ключевое событие, известное как InstanceEvents.load () , для создания атрибутивного заполнения поведение при загрузке объекта.Одним из таких примеров является двунаправленный Случай «один к одному», когда загрузка стороны «многие к одному» также должно подразумевать значение стороны «один ко многим». SQLAlchemy ORM не учитывает обратные ссылки при загрузке связанных объектов и просматривает «Один-к-одному» как просто еще один «один-ко-многим», это просто один ряд.

Учитывая следующее сопоставление:

 из sqlalchemy import Integer, ForeignKey, Column
из отношения импорта sqlalchemy.orm, обратная ссылка
из sqlalchemy.ext.declarative import declarative_base

База = декларативная_база ()


класс А (Базовый):
    __tablename__ = 'а'
    id = столбец (целое число, primary_key = True)
    b_id = Столбец (ForeignKey ('b.id'))
    b = отношения (
        "Б",
        backref = backref ("a", uselist = False),
        ленивый = 'присоединился')


класс B (Базовый):
    __tablename__ = 'b'
    id = Столбец (Целое число, primary_key = True) 

Если мы запросим строку A , а затем запросим a.b.a , мы получим дополнительный SELECT:

 >>> a1.б.а
ВЫБЕРИТЕ a.id как a_id, a.b_id как a_b_id
Из
КУДА ? = a.b_id 

Этот SELECT является избыточным, поскольку b.a — это то же значение, что и a1 . Мы может создать правило загрузки, чтобы заполнить это для нас:

 из события импорта sqlalchemy
из атрибутов импорта sqlalchemy.orm

@ event.listens_for (A, "загрузка")
def load_b (цель, контекст):
    если 'b' в target .__ dict__:
        attributes.set_committed_value (target.b, 'a', target) 

Теперь, когда мы запросим A , мы получим A.b из присоединенной нетерпеливой нагрузки, и A.b.a с нашего мероприятия:

 a1 = s.query (A) .first ()
 
 ВЫБРАТЬ
    a.id AS a_id,
    a.b_id AS a_b_id,
    b_1.id AS b_1_id
Из
ЛЕВОЕ ВНЕШНЕЕ СОЕДИНЕНИЕ b AS b_1 ON b_1.id = a.b_id
 LIMIT? КОМПЕНСИРОВАТЬ ?
(1, 0)
 
 assert a1.b.a is a1 

API загрузчика отношений

функция sqlalchemy.orm.contains_eager ( * ключи , ** кВт )

Указывает, что данный атрибут должен быть загружен из столбцы, указанные вручную в запросе.

Эта функция является частью интерфейса Load и поддерживает как цепочка методов, так и автономная работа.

Опция используется вместе с явным соединением, которое загружает желаемые строки, т.е.:

 sessions.query (Заказ). \
        присоединиться (Order.user). \
        параметры (contains_eager (Order.user)) 

Вышеупомянутый запрос будет соединяться от объекта Order к соответствующему Пользователь , и возвращенные объекты Order будут иметь Атрибут Order.user предварительно заполнен.

Его также можно использовать для настройки записей в быстро загруженном коллекция; запросы обычно хотят использовать Query.populate_existing () , предполагающий основной коллекция родительских объектов, возможно, уже была загружена:

 сессиязапрос (Пользователь). \
    присоединиться (User.addresses). \
    filter (Address.email_address.like ('% @ aol.com')). \
    options (contains_eager (User.addresses)). \
    populate_existing () 

См. Раздел «Маршрутизация явных объединений / операторов в быстро загружаемые коллекции» для получения полных сведений об использовании.

функция sqlalchemy.orm.defaultload ( * ключи )

Указывает, что атрибут должен загружаться с использованием стиля загрузчика по умолчанию.

Этот метод используется для ссылки на другие параметры загрузчика далее в цепочка атрибутов без изменения стиля загрузчика ссылок по цепочке.Например, чтобы установить объединенную активную загрузку для элемент элемента:

 session.query (MyClass) .options (
    defaultload (MyClass.someattribute).
    connectedload (MyOtherClass.someotherattribute)
) 

defaultload () также полезен для настройки параметров на уровне столбца в родственном классе, а именно в классе defer () и undefer () :

 session.query (MyClass) .options (
    defaultload (MyClass.someattribute).
    отложить ("некоторый_столбец").
    undefer ("some_other_column")
) 

функция sqlalchemy.orm.eagerload ( * args , ** kwargs )

Синоним для connectedload () .

Не рекомендуется, начиная с версии 1.4: конструкция eagerload считается устаревшей в серии 1.x SQLAlchemy и будет удалена в версии 2.0. Пожалуйста, используйте connectedload () . (Сведения о SQLAlchemy 2.0: переход на SQLAlchemy 2.0)

функция sqlalchemy.orm.immediateload ( * ключи )

Указывает, что данный атрибут должен быть загружен с использованием немедленная загрузка с помощью оператора SELECT для каждого атрибута.

Загрузка достигается с помощью стратегии «ленивого загрузчика» и не отключите любые дополнительные нетерпеливые загрузчики.

Параметр немедленной загрузки () заменен в целом опцией selectinload () , которая выполняет ту же задачу более эффективно, выпуская SELECT для всех загруженных объектов.

Эта функция является частью интерфейса Load и поддерживает как цепочка методов, так и автономная работа.

функция sqlalchemy.orm.joinedload ( * ключи , ** кВт )

Указывает, что данный атрибут должен быть загружен с использованием объединенного нетерпеливая загрузка.

Эта функция является частью интерфейса Load и поддерживает как цепочка методов, так и автономная работа.

примеры:

 # connected - загрузить коллекцию «заказы» на «Пользователь»
query (Пользователь) .options (connectedload (User.orders))

# connected-load Order.items, а затем Item.keywords
запрос (Порядок) .options (
    connectedload (заказ.items) .joinedload (Item.keywords))

# лениво загружать Order.items, но когда Items загружаются,
# connected - загрузить коллекцию ключевых слов
запрос (Порядок) .options (
    lazyload (Order.items) .joinedload (Item.keywords)) 

Параметры

внутреннее соединение —

, если Истинно , указывает, что объединенная активная нагрузка должна использовать внутреннее соединение вместо левого внешнего соединения по умолчанию:

 query (Order) .options (connectedload (Order.user, innerjoin = True)) 

Для того, чтобы связать несколько активных объединений вместе, где некоторые могут быть ВНЕШНИЙ и другие ВНУТРЕННИЕ, для их связывания используются правые вложенные соединения:

 запрос (A).параметры(
    connectedload (A.bs, innerjoin = False).
        connectedload (B.cs, innerjoin = True)
) 

Вышеупомянутый запрос, связывающий A.bs через «внешнее» соединение и B.cs через «внутреннее» соединение. будет отображать соединения как «LEFT OUTER JOIN (b JOIN c)». Когда используешь в более старых версиях SQLite (<3.7.16) эта форма JOIN переведена на используйте полные подзапросы, поскольку этот синтаксис напрямую не поддерживается.

Флаг внутреннего соединения также можно указать с помощью термина «невложенный» .Это указывает на то, что следует использовать INNER JOIN, , если не соединение связан с LEFT OUTER JOIN слева, и в этом случае он будет отображаться как LEFT OUTER JOIN. Например, предположим, что A.bs внешнее соединение:

 запрос (A) .options (
    joinload (A.bs).
        connectedload (B.cs, innerjoin = "unnested")
) 

Приведенное выше соединение будет отображаться как «LEFT OUTER JOIN b LEFT OUTER JOIN c», а не как «LEFT OUTER JOIN (b JOIN c)».

Примечание

Флаг «unnested» не влияет на отображение , а не на JOIN. из таблицы ассоциаций «многие ко многим», e.грамм. стол настроен как Relations.secondary для целевой таблицы; для правильность результатов, эти соединения всегда ВНУТРЕННИЕ и следовательно, вложены вправо, если связаны с ВНЕШНИМ соединением.

функция sqlalchemy.orm.lazyload ( * ключи )

Указывает, что данный атрибут должен быть загружен с использованием «ленивого» загрузка.

Эта функция является частью интерфейса Load и поддерживает как цепочка методов, так и автономная работа.

класс sqlalchemy.orm.Load ( объект )

Представляет параметры загрузчика, которые изменяют состояние Запрос , чтобы повлиять на то, как различные сопоставленные атрибуты загружен.

Объект Load в большинстве случаев используется неявно за сцены, когда используется параметр запроса, например, connectedload () , defer () или аналогичный. Однако объект Load также могут использоваться напрямую, а в некоторых случаях могут быть полезны.

Чтобы использовать Load напрямую, создайте его экземпляр с сопоставленной целью класс в качестве аргумента. Этот стиль использования полезно при работе с запросом с несколькими объектами:

 myopt = Load (MyClass) .joinedload ("виджеты") 

Вышеупомянутый myopt теперь можно использовать с Query.options () , где это вступит в силу только для объекта MyClass :

 session.query (MyClass, MyOtherClass) .options (myopt) 

Один случай, когда Нагрузка полезен, поскольку общедоступный API используется при указании Параметры «подстановочного знака», которые действуют только для определенного класса:

 сеанс.query (Порядок) .options (Загрузить (Порядок) .lazyload ('*')) 

Выше все отношения по заказу будут загружаться лениво, но другие атрибуты этих дочерних объектов будут загружаться, используя свои обычные стратегия загрузчика.

Обозначение класса

класс sqlalchemy.orm.Load ( sqlalchemy.sql.expression.Generative , sqlalchemy.orm.LoaderOption )

метод sqlalchemy.orm.Load. baked_lazyload ( attr )

Создайте новый объект Load с baked_lazyload () опция применена.

Примеры использования см. В baked_lazyload () .

метод sqlalchemy.orm.Load. contains_eager ( attr , alias = None )

Создайте новый объект Load с contains_eager () опция применена.

Примеры использования см. В contains_eager () .

метод sqlalchemy.orm.Load. загрузка по умолчанию ( attr )

Создайте новый объект Load с defaultload () опция применена.

См. Примеры использования defaultload () .

метод sqlalchemy.orm.Load. defer ( key , raiseload = False )

Создайте новый объект Load с defer () опция применена.

Примеры использования см. В defer () .

метод sqlalchemy.orm.Load. немедленная загрузка ( attr )

Создайте новый объект Load с немедленная загрузка () опция применена.

Примеры использования см. В разделе немедленной загрузки () .

метод sqlalchemy.orm.Load. connectedload ( attr , innerjoin = None )

Создайте новый объект Load с connectedload () опция применена.

Примеры использования см. В разделе connectedload () .

метод sqlalchemy.orm.Load. отложенная загрузка ( attr )

Создайте новый объект Load с lazyload () опция применена.

Примеры использования см. В lazyload () .

метод sqlalchemy.orm.Load. load_only ( * attrs )

Создайте новый объект Load с load_only () опция применена.

Примеры использования см. В load_only () .

метод sqlalchemy.orm.Load. без нагрузки ( attr )

Создайте новый объект Load с noload () опция применена.

Примеры использования см. В noload () .

метод sqlalchemy.orm.Load. опций ( * опц )

Примените к этому ряду дополнительных опций. Нагрузка объект.

Например:

 query = session.query (Автор)
query = query.options (
            connectedload (Автор.book) .options (
                load_only (Book.summary, Book.excerpt),
                connectedload (Book.citations).параметры(
                    connectedload (Citation.author)
                )
            )
        ) 

Параметры

* opts — серия объектов опций загрузчика (в конечном итоге Загрузить объектов), которые следует применить к пути заданный этим объектом Load .

метод sqlalchemy.orm.Load. состояние_компиляции_процесса ( состояние_компиляции )

Применить модификацию к данному CompileState .

метод sqlalchemy.orm.Load. process_compile_state_replaced_entities ( compile_state , mapper_entities )

Применить модификацию к данному CompileState , данные объекты, которые были заменены with_only_columns () или with_entities ().

метод sqlalchemy.orm.Load. raiseload ( attr , sql_only = False )

Создайте новый объект Load с raiseload () опция применена.

Примеры использования см. В разделе raiseload () .

метод sqlalchemy.orm.Load. selectin_polymorphic ( классы )

Создайте новый объект Load с selectin_polymorphic () опция применена.

Примеры использования см. В разделе selectin_polymorphic () .

метод sqlalchemy.orm.Load. selectinload ( attr )

Создайте новый объект Load с selectinload () опция применена.

Примеры использования см. В selectinload () .

метод sqlalchemy.orm.Load. подзапрос ( attr )

Создайте новый объект Load с subqueryload () опция применена.

Примеры использования см. В subqueryload () .

метод sqlalchemy.orm.Load. undefer ( ключ )

Создайте новый объект Load с undefer () опция применена.

Примеры использования см. В undefer () .

метод sqlalchemy.orm.Load. undefer_group ( имя )

Создайте новый объект Load с undefer_group () опция применена.

Примеры использования см. В undefer_group () .

метод sqlalchemy.orm.Load. with_expression ( ключ , выражение )

Создайте новый объект Load с with_expression () опция применена.

Примеры использования см. В with_expression () .

функция sqlalchemy.orm.noload ( * ключи )

Указывает, что данный атрибут отношения должен оставаться незагруженным.

Атрибут отношения вернет Нет при доступе без производят какой-либо эффект нагрузки.

Эта функция является частью интерфейса Load и поддерживает как цепочка методов, так и автономная работа.

noload () применяется к атрибутам Relations () ; для атрибуты на основе столбцов, см. defer () .

Примечание

Установка этой стратегии загрузки в качестве стратегии по умолчанию для отношений, использующих отношение . ленивый параметр может вызвать проблемы с сбросом, например, если операция удаления необходимо загрузить связанные объекты, и вместо этого Не было возвращено .

функция sqlalchemy.orm.raiseload ( * ключи , ** квт )

Указывает, что данный атрибут должен вызывать ошибку при доступе.

Атрибут отношения, настроенный с помощью raiseload () , будет вызывает ошибку InvalidRequestError при доступе. В обычно это полезно, когда приложение пытается обеспечить что все атрибуты отношений, к которым осуществляется доступ в определенном контексте уже были бы загружены из-за нетерпеливой загрузки. Вместо того, чтобы иметь для чтения журналов SQL, чтобы убедиться, что ленивая загрузка не происходит, это стратегия заставит их немедленно поднять ставку.

raiseload () применяется к взаимосвязи () только атрибуты. Чтобы применить поведение повышения при SQL к атрибуту на основе столбца, используйте параметр defer.raiseload для defer () вариант загрузчика.

Параметры

sql_only — если True, поднять, только если ленивая загрузка выдаст SQL, но нет, если он только проверяет карту идентичности или определяет, что связанное значение должно быть просто None из-за отсутствия ключей.Когда ложно, стратегия будет повышать нагрузку на все разновидности отношений.

Эта функция является частью интерфейса Load и поддерживает как цепочка методов, так и автономная работа.

функция sqlalchemy.orm.selectinload ( * ключи )

Указывает, что данный атрибут должен быть загружен с использованием ВЫБРАТЬ В нетерпеливой загрузке.

Эта функция является частью интерфейса Load и поддерживает как цепочка методов, так и автономная работа.

примеры:

 # selectin-загрузить коллекцию "заказы" на "Пользователь"
query (Пользователь) .options (selectinload (User.orders))

# selectin-load Order.items, а затем Item.keywords
запрос (Порядок) .options (
    selectinload (Order.items) .selectinload (Item.keywords))

# лениво загружать Order.items, но когда Items загружаются,
# selectin-загрузка коллекции ключевых слов
запрос (Порядок) .options (
    lazyload (Order.items) .selectinload (Item.keywords)) 

функция sqlalchemy.orm.subqueryload ( * ключи )

Указывает, что данный атрибут должен быть загружен с использованием подзапрос ждет загрузки.

Эта функция является частью интерфейса Load и поддерживает как цепочка методов, так и автономная работа.

примеры:

 # подзапрос - загрузка коллекции заказов для пользователя
query (Пользователь) .options (subqueryload (User.orders))

# subquery-load Order.items, а затем Item.keywords
запрос (Порядок) .options (
    подзапрос (заказ.items) .subqueryload (Item.keywords))

# лениво загружать Order.items, но когда Items загружаются,
# подзапрос - загрузка коллекции ключевых слов
запрос (Порядок) .options (
    lazyload (Order.items) .subqueryload (Item.keywords)) 

Эффективная загрузка изображений в представлениях таблиц и коллекций — Донни Уолс

Опубликовано: 4 декабря 2019 г.

Когда ваше приложение показывает изображения из сети в виде таблицы или коллекции, вам необходимо загружать изображения асинхронно, чтобы убедитесь, что ваш список прокручивается плавно.Что еще более важно, вам нужно будет каким-то образом связать изображение, которое вы загружаете, с правильной ячейкой в ​​вашем списке (вместо представления таблицы или представления коллекции я теперь буду называть список). И если ячейка выходит из поля зрения и повторно используется для отображения новых данных с новым изображением, вам нужно отменить текущую загрузку изображения, чтобы гарантировать немедленную загрузку новых изображений. И, чтобы убедиться, что мы не подключаемся к сети чаще, чем необходимо, нам понадобится какой-то способ кэширования изображений в памяти или на диске, чтобы мы могли использовать локальную версию изображения, если мы уже загрузили это в прошлом.Основываясь на этом, мы можем определить три основные проблемы, которые нам необходимо решить при асинхронной загрузке изображений для наших ячеек:

1. Установка загруженного изображения в правильную ячейку.
2. Отмена незавершенной загрузки при повторном использовании ячейки.
3. Кэширование загруженных изображений во избежание ненужных сетевых вызовов.

В этом посте я покажу вам, как создать простой класс загрузчика изображений и написать ячейку табличного представления, которая поможет нам решить все эти проблемы. Я также покажу вам, как вы можете использовать тот же загрузчик изображений для улучшения UIImage с помощью некоторых необычных помощников.

Создание простого загрузчика изображений

Когда вы делаете запрос GET с использованием URLSession , вы обычно делаете это через задачу данных. Обычно вы не держитесь за эту задачу с данными, потому что она вам не нужна. Но если вы сохраните ссылку на свою задачу с данными, вы можете отменить ее позже. Я собираюсь использовать словарь [UUID: URLSessionDataTask] в создаваемом нами загрузчике изображений, потому что это позволит мне отслеживать текущие загрузки и отменять их позже.Я также собираюсь использовать словарь [URL: UIImage] в качестве простого кеша в памяти для загруженных изображений. Исходя из этого, мы можем начать писать загрузчик изображений:

  class ImageLoader {
  private var loadedImages = [URL: UIImage] ()
  private var runningRequests = [UUID: URLSessionDataTask] ()
}
  

Мы также можем реализовать метод loadImage (_: Завершение :) . Этот метод будет принимать URL-адрес и обработчик завершения, и он будет возвращать UUID, который позже будет использоваться для уникальной идентификации каждой задачи с данными.Реализация выглядит следующим образом:

  func loadImage (_ url: URL, _ завершения: @escaping (Result ) -> Void) -> UUID? {

  // 1
  if let image = loadedImages [url] {
    завершение (.success (изображение))
    вернуть ноль
  }

  // 2
  пусть uuid = UUID ()

  let task = URLSession.shared.dataTask (with: url) {data, response, error in
    // 3
    отложить {self.runningRequests.removeValue (forKey: uuid)}

    // 4
    если let data = data, let image = UIImage (data: data) {
      себя.loadedImages [url] = изображение
      завершение (.success (изображение))
      возвращение
    }

    // 5
    guard let error = error else {
      // без изображения или ошибки, мы пока просто проигнорируем это
      // вы можете добавить свои собственные специальные случаи ошибок для этого сценария
      возвращение
    }

    guard (ошибка как NSError) .code == NSURLErrorCancelled else {
      завершение (.failure (error))
      возвращение
    }

    // запрос был отменен, обратный вызов вызывать не нужно
  }
  task.resume ()

  // 6
  runningRequests [uuid] = задача
  вернуть uuid
}
  

Давайте рассмотрим предыдущий код шаг за шагом, следуя пронумерованным комментариям.

1. Если URL-адрес уже существует в качестве ключа в нашем кэше в памяти, мы можем немедленно вызвать обработчик завершения. Поскольку нет активной задачи и нечего отменить позже, мы можем вернуть nil вместо экземпляра UUID .
2. Мы создаем экземпляр UUID , который используется для идентификации задачи данных, которую мы собираемся создать.
3. Когда задача данных завершена, ее следует удалить из словаря текущих запросов. Здесь мы используем оператор defer , чтобы удалить запущенную задачу, прежде чем мы покинем область действия обработчика завершения задачи данных.
4. Когда задача данных завершается и мы можем извлечь изображение из результата задачи данных, оно кэшируется в кеш-памяти в памяти и вызывается обработчик завершения с загруженным изображением. После этого мы можем вернуться из обработчика завершения задачи данных.
5. Если мы получаем сообщение об ошибке, мы проверяем, не связана ли ошибка с отменой задачи. Если ошибка связана с чем-либо, кроме отмены задачи, мы пересылаем ее вызывающей стороне loadImage (_: Завершение :) .
6. Задача данных хранится в словаре текущих запросов с использованием UUID , который был создан на шаге 2.Этот UUID затем возвращается вызывающей стороне.

Обратите внимание, что шаги с 3 по 5 выполняются в обработчике завершения задачи данных. Это означает, что порядок выполнения перечисленных шагов не является линейным. Сначала выполняются шаги 1 и 2, затем шаги 6, а затем шаги с 3 по 5.

Теперь, когда у нас есть логика для загрузки наших изображений, давайте рассмотрим некоторую логику, которая позволяет нам также отменять незавершенную загрузку изображений:

  func cancelLoad (_ uuid: UUID) {
  runningRequests [uuid] ?.Отмена()
  runningRequests.removeValue (forKey: uuid)
}
  

Этот метод получает UUID , использует его для поиска выполняющейся задачи данных и отменяет эту задачу. Он также удаляет задачу из словаря запущенных задач, если он существует. Довольно просто, правда?

Давайте посмотрим, как использовать этот загрузчик в методе cellForRowAtIndexPath табличного представления:

  // 1
let token = loader.loadImage (imageUrl) {результат
  делать {
    // 2
    let image = попробуйте результат.получать()
    // 3
    DispatchQueue.main.async {
      cell.cellImageView.image = изображение
    }
  } ловить {
    // 4
    печать (ошибка)
  }
}

// 5
cell.onReuse = {
  if let token = token {
    self.loader.cancelLoad (токен)
  }
}
  

Давайте еще раз пройдемся по предыдущему коду шаг за шагом:

1. Вызывается метод loadImage (_: Завершение 🙂 загрузчика изображений, и UUID, возвращаемый загрузчиком, сохраняется в константе.
2. В обработчике завершения для loadImage (_: Завершение :) мы извлекаем результат из аргумента результата завершения.
3. Если мы успешно извлекли изображение, мы отправляем его в основную очередь и устанавливаем извлеченное изображение в свойстве imageView ячейки. Не знаете, что такое отправка в основную очередь? Подробнее в этом посте
4. Если что-то пошло не так, распечатайте ошибку. Возможно, вы захотите сделать что-нибудь еще здесь, в своем приложении.
5. Вскоре я покажу вам пример моего подкласса ячеек. Важным моментом является то, что мы используем UUID, который мы получили от loadImage (_: Завершение :) , чтобы отменить операцию загрузки загрузчика для этого UUID.

Обратите внимание, что мы делаем это в методе cellForRowAt . Это означает, что каждый раз, когда нас просят отобразить ячейку в нашем списке, этот метод вызывается для этой ячейки. Таким образом, загрузка и отмена довольно тесно связаны с жизненным циклом ячейки, что нам и нужно в данном случае. Давайте посмотрим, что onReuse находится в ячейке примера:

  class ImageCell: UITableViewCell {
  @IBOutlet var cellImageView: UIImageView!
  var onReuse: () -> Void = {}

  override func prepareForReuse () {
    супер.prepareForReuse ()
    onReuse ()
    cellImageView.image = ноль
  }
}
  

Свойство onReuse — это закрытие, которое мы вызываем, когда вызывается метод prepareForReuse ячейки. Мы также удаляем текущее изображение из ячейки в prepareForReuse , чтобы оно не отображало старое изображение при загрузке нового. Ячейки используются повторно довольно часто, поэтому выполнение соответствующей очистки в файле prepareForReuse имеет решающее значение для предотвращения появления артефактов из старых данных в ячейке, когда вы этого не хотите.

Если вы реализуете все это в своем приложении, у вас будет приличная стратегия загрузки изображений. Вы, вероятно, захотите добавить прослушиватель для предупреждений о памяти, которые генерируются центром уведомлений вашего приложения, и, возможно, вы захотите кэшировать изображения на диск, а также в память, но я не думаю, что это хорошо вписывается в рамки этого статья на данный момент. Помните об этих двух функциях, если вы хотите реализовать свой собственный загрузчик изображений. Особенно важно прислушиваться к предупреждениям о памяти, поскольку ваше приложение может быть убито ОС, если оно потребляет слишком много памяти, сохраняя изображения в кеш-памяти в памяти.

Улучшение UIImageView для создания красивого API загрузки изображений

Прежде чем мы реализуем причудливые помощники, давайте реорганизуем нашу ячейку и метод cellForRowAt , чтобы они уже содержали код, который мы хотим написать. Метод prepareForReuse будет выглядеть следующим образом:

  override func prepareForReuse () {
  cellImageView.image = ноль
  cellImageView.cancelImageLoad ()
}
  

Это установит для текущего изображения значение nil и укажет представлению изображения прекратить загрузку изображения, которое оно загружало.Весь код загрузки изображения в cellForRowAt следует заменить следующим:

  cell.cellImageView.loadImage (at: imageUrl)
  

Да, весь этот код, который у нас был раньше, теперь представляет собой одну строку.

Чтобы сделать этот новый способ загрузки и отмены работы, мы собираемся реализовать специальный класс загрузчика изображений под названием UIImageLoader . Это будет одноэлементный объект, который управляет загрузкой для всех экземпляров UIImageView в вашем приложении, что означает, что вы в конечном итоге используете единый кеш для всего приложения.Обычно вы этого не хотите, но в данном случае я думаю, что это имеет смысл. Следующий код описывает скелет UIImageLoader :

  class UIImageLoader {
  статический let loader = UIImageLoader ()

  частный let imageLoader = ImageLoader ()
  private var uuidMap = [UIImageView: UUID] ()

  частный init () {}

  func load (_ url: URL, для imageView: UIImageView) {

  }

  func cancel (для imageView: UIImageView) {

  }
}
  

Сам загрузчик является статическим экземпляром и использует ImageLoader из предыдущего раздела для фактической загрузки изображений и их кеширования.У нас также есть словарь [UIImageView: UUID] для отслеживания текущих активных задач загрузки изображений. Мы сопоставляем их на основе UIImageView , чтобы мы могли связать идентификаторы отдельных задач с экземплярами UIImageView .

Реализация метода load (_: for :) выглядит следующим образом:

  func load (_ url: URL, for imageView: UIImageView) {
  // 1
  let token = imageLoader.loadImage (url) {результат
    // 2
    отложить {себя.uuidMap.removeValue (forKey: imageView)}
    делать {
      // 3
      пусть изображение = попробуйте result.get ()
      DispatchQueue.main.async {
        imageView.image = изображение
      }
    } ловить {
      // обрабатываем ошибку
    }
  }

  // 4
  if let token = token {
    uuidMap [imageView] = токен
  }
}
  

Шаг за шагом этот код выполняет следующие действия:

1. Мы инициируем загрузку изображения, используя URL, который тоже был передан. load (_: for :) .
2. Когда загрузка завершена, нам нужно очистить uuidMap , удалив UIImageView , для которого мы загружаем изображение из словаря.
3. Это похоже на то, что было сделано в cellForRowAt ранее. Изображение извлекается из результата и устанавливается в самом просмотре изображения.
4. Наконец, если мы получили токен от загрузчика изображений, мы сохраняем его в словаре [UIImageView: UUID] , чтобы мы могли ссылаться на него позже, если загрузка должна быть отменена.

Метод cancel (для :) имеет следующую реализацию:

  func cancel (для imageView: UIImageView) {
  if let uuid = uuidMap [imageView] {
    imageLoader.cancelLoad (uuid)
    uuidMap.removeValue (forKey: imageView)
  }
}
  

Если у нас есть активная загрузка для просмотра переданного изображения, она отменяется и удаляется из uuidMap . Очень похоже на то, что вы видели раньше.

Все, что нам нужно сделать сейчас, это добавить расширение к UIImageView , чтобы добавить метод loadImage (at :) и cancelImageLoad () , который вы видели ранее:

  extension UIImageView {
  func loadImage (по адресу: URL) {
    UIImageLoader.loader.load (url, для: self)
  }

  func cancelImageLoad () {
    UIImageLoader.loader.cancel (для: себя)
  }
}
  

Оба метода передают self загрузчику изображений. Поскольку методы расширения добавляются к экземплярам UIImageView , это помогает загрузчику изображений подключать URL-адрес, который он загружает, к экземпляру UIImageView , который мы хотим показать изображение, оставляя нам очень простой и легкий в использовании API. ! Классная штука, правда?

Что еще лучше, так это то, что эту новую стратегию можно также использовать для изображений, которых нет в ячейке табличного представления или ячейки представления коллекции.Его можно использовать буквально для просмотра любого изображения в вашем приложении!

Резюме

Асинхронная загрузка данных сама по себе может стать серьезной проблемой. В сочетании с мимолетным характером ячеек табличного представления (и представления коллекции) вы сталкиваетесь с совершенно новым кругом проблем. В этом посте вы увидели, как можно использовать URLSession и очень простой кеш в памяти для реализации интеллектуального механизма для запуска, завершения и отмены загрузки изображений.

После создания простого механизма вы увидели, как создать объект дополнительного загрузчика и некоторые расширения для UIImageView , чтобы создать очень простой и легкий в использовании API для загрузки изображений из URL-адресов непосредственно в представления изображений.

Имейте в виду, что реализации, которые я вам здесь показал, еще не готовы к работе. Вам нужно будет немного поработать с точки зрения управления памятью и, возможно, добавить дисковый кеш, чтобы эти объекты были готовы к работе в прайм-тайм.