Внутренние компоненты ORM ¶

Составление из свойств столбцов во время отображения

Классная подпись

класс sqlalchemy.orm.ColumnProperty.Comparator (sqlalchemy.util.langhelpers.MemoizedSlots, sqlalchemy.orm.PropComparator)

attribute sqlalchemy.orm.ColumnProperty.Comparator.expressions: Sequence[NamedColumn[Any]]¶

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

Добавлено в версии 1.3.17.

См.также

Сопоставление класса с несколькими таблицами - пример использования

method sqlalchemy.orm.ColumnProperty.Comparator.operate(op: OperatorType, *other: Any, **kwargs: Any) → ColumnElement[Any]¶

Оперировать с аргументом.

Это самый низкий уровень работы, по умолчанию поднимает NotImplementedError.

Переопределение этого параметра в подклассе может позволить применять общее поведение ко всем операциям. Например, переопределение ColumnOperators для применения func.lower() к левой и правой стороне:

class MyComparator(ColumnOperators):
    def operate(self, op, other, **kwargs):
        return op(func.lower(self), func.lower(other), **kwargs)

Параметры:

op – Вызов оператора.
*other – «другая» сторона операции. Для большинства операций это будет один скаляр.
**kwargs – модификаторы. Они могут передаваться специальными операторами, такими как ColumnOperators.contains().

method sqlalchemy.orm.ColumnProperty.Comparator.reverse_operate(op: OperatorType, other: Any, **kwargs: Any) → ColumnElement[Any]¶

Обратное действие над аргументом.

Используется так же, как и operate().

attribute sqlalchemy.orm.ColumnProperty.columns_to_assign¶

method sqlalchemy.orm.ColumnProperty.declarative_scan(decl_scan: _ClassScanMapperConfig, registry: _RegistryType, cls: Type[Any], originating_module: Optional[str], key: str, mapped_container: Optional[Type[Mapped[Any]]], annotation: Optional[_AnnotationScanType], extracted_mapped_annotation: Optional[_AnnotationScanType], is_dataclass_field: bool) → None¶: Выполняйте специфическую для класса инициализацию на ранних стадиях декларативного сканирования.

Добавлено в версии 2.0.

method sqlalchemy.orm.ColumnProperty.do_init() → None¶

Выполните шаги инициализации, специфичные для подклассов, после создания картографа.

Это шаблонный метод, вызываемый методом init() объекта MapperProperty.

attribute sqlalchemy.orm.ColumnProperty.expression¶

Возвращает первичный столбец или выражение для данного ColumnProperty.

Например:

class File(Base):
    # ...

    name = Column(String(64))
    extension = Column(String(8))
    filename = column_property(name + '.' + extension)
    path = column_property('C:/' + filename.expression)

См.также

method sqlalchemy.orm.ColumnProperty.instrument_class(mapper: Mapper[Any]) → None¶

Крючок, вызываемый маппером свойства для инициирования инструментации атрибута класса, управляемого этим MapperProperty.

Здесь MapperProperty обычно обращается к модулю атрибутов для установки InstrumentedAttribute.

Этот шаг является первым из двух шагов для установки InstrumentedAttribute, и вызывается в самом начале процесса настройки маппера.

Вторым шагом обычно является шаг init_class_attribute, вызываемый из StrategizedProperty через хук post_instrument_class(). Этот шаг назначает дополнительное состояние InstrumentedAttribute (в частности, «impl»), которое было определено после того, как MapperProperty определил, какой тип управления персистентностью ему нужно сделать (например, скаляр, объект, коллекция и т.д.).

attribute sqlalchemy.orm.ColumnProperty.mapper_property_to_assign¶

method sqlalchemy.orm.ColumnProperty.merge(session: Session, source_state: InstanceState[Any], source_dict: _InstanceDict, dest_state: InstanceState[Any], dest_dict: _InstanceDict, load: bool, _recursive: Dict[Any, object], _resolve_conflict_map: Dict[_IdentityKeyType[Any], object]) → None¶: Объединить атрибут, представленный этим MapperProperty, с объектом-источником и объектом-получателем.

class sqlalchemy.orm.Composite¶

Декларативно-совместимый внешний интерфейс для класса CompositeProperty.

Публичный конструктор - это функция composite().

Изменено в версии 2.0: Добавлен Composite как подкласс CompositeProperty, совместимый с Declarative.

См.также

Типы составных колонн

Классная подпись

класс sqlalchemy.orm.Composite (sqlalchemy.orm.descriptor_props.CompositeProperty, sqlalchemy.orm.base._DeclarativeMapped)

class sqlalchemy.orm.CompositeProperty¶

Определяет «составной» сопоставленный атрибут, представляющий коллекцию столбцов как один атрибут.

CompositeProperty строится с помощью функции composite().

См.также

Типы составных колонн

Members

create_row_processor(), columns_to_assign, declarative_scan(), do_init(), get_history(), instrument_class(), mapper_property_to_assign

Классная подпись

class sqlalchemy.orm.CompositeProperty (sqlalchemy.orm._MapsColumns, sqlalchemy.orm._IntrospectsAnnotations, sqlalchemy.orm.descriptor_props.DescriptorProperty)

class Comparator¶

Производить булевы, сравнительные и другие операторы для атрибутов Composite.

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

См.также

PropComparator

Mapper.all_orm_descriptors

Классная подпись

класс sqlalchemy.orm.CompositeProperty.Comparator (sqlalchemy.orm.PropComparator)

class CompositeBundle¶

Классная подпись

класс sqlalchemy.orm.CompositeProperty.CompositeBundle (sqlalchemy.orm.Bundle)

method sqlalchemy.orm.CompositeProperty.CompositeBundle.create_row_processor(query: Select[Any], procs: Sequence[Callable[[Row[Any]], Any]], labels: Sequence[str]) → Callable[[Row[Any]], Any]¶

Произведите функцию «обработки строки» для данного Bundle.

Может переопределяться подклассами для обеспечения пользовательского поведения при получении результатов. Во время выполнения запроса методу передается объект statement и набор функций «row processor»; эти функции при получении строки результата возвращают значение отдельного атрибута, которое затем может быть адаптировано в любую структуру возвращаемых данных.

Приведенный ниже пример иллюстрирует замену обычной структуры возврата Row на прямой словарь Python:

from sqlalchemy.orm import Bundle

class DictBundle(Bundle):
    def create_row_processor(self, query, procs, labels):
        'Override create_row_processor to return values as
        dictionaries'

        def proc(row):
            return dict(
                zip(labels, (proc(row) for proc in procs))
            )
        return proc

Результат из приведенного выше Bundle вернет значения словаря:

bn = DictBundle('mybundle', MyClass.data1, MyClass.data2)
for row in session.execute(select(bn)).where(bn.c.data1 == 'd1'):
    print(row.mybundle['data1'], row.mybundle['data2'])

attribute sqlalchemy.orm.CompositeProperty.columns_to_assign¶

method sqlalchemy.orm.CompositeProperty.declarative_scan(decl_scan: _ClassScanMapperConfig, registry: _RegistryType, cls: Type[Any], originating_module: Optional[str], key: str, mapped_container: Optional[Type[Mapped[Any]]], annotation: Optional[_AnnotationScanType], extracted_mapped_annotation: Optional[_AnnotationScanType], is_dataclass_field: bool) → None¶: Выполняйте специфическую для класса инициализацию на ранних стадиях декларативного сканирования.

Добавлено в версии 2.0.

method sqlalchemy.orm.CompositeProperty.do_init() → None¶: Инициализация, которая происходит после того, как Composite был связан со своим родительским картографом.

method sqlalchemy.orm.CompositeProperty.get_history(state: InstanceState[Any], dict_: _InstanceDict, passive: PassiveFlag = symbol('PASSIVE_OFF')) → History¶: Предоставляется для пользовательского кода, который использует attributes.get_history().

method sqlalchemy.orm.CompositeProperty.instrument_class(mapper: Mapper[Any]) → None¶

Здесь MapperProperty обычно обращается к модулю атрибутов для установки InstrumentedAttribute.

attribute sqlalchemy.orm.CompositeProperty.mapper_property_to_assign¶

class sqlalchemy.orm.AttributeEventToken¶

Жетон, распространяемый по всей цепочке событий атрибута.

Служит индикатором источника события, а также обеспечивает средство контроля распространения по цепочке операций с атрибутами.

Объект Event передается в качестве аргумента initiator при работе с такими событиями, как AttributeEvents.append(), AttributeEvents.set() и AttributeEvents.remove().

Объект Event в настоящее время интерпретируется обработчиками событий backref и используется для управления распространением операций по двум взаимозависимым атрибутам.

Изменено в версии 2.0: Изменил название с AttributeEvent на AttributeEventToken.

атрибут impl:: AttributeImpl, который является инициатором текущего события.
атрибут op:: Символ OP_APPEND, OP_REMOVE, OP_REPLACE или OP_BULK_REPLACE, указывающий на операцию источника.

class sqlalchemy.orm.IdentityMap¶

Members

check_modified()

method sqlalchemy.orm.IdentityMap.check_modified() → bool¶: возвращает True, если все присутствующие InstanceStates были помечены как «измененные».

class sqlalchemy.orm.InspectionAttr¶

Базовый класс, применяемый ко всем объектам и атрибутам ORM, которые связаны с вещами, которые могут быть возвращены функцией inspect().

Определенные здесь атрибуты позволяют использовать простые булевы проверки для проверки основных фактов о возвращаемом объекте.

Members

extension_type, is_aliased_class, is_attribute, is_bundle, is_clause_element, is_instance, is_mapper, is_property, is_selectable

Хотя проверка булевых значений здесь в основном такая же, как и при использовании функции Python isinstance(), флаги здесь можно использовать без необходимости импортировать все эти классы, а также таким образом, чтобы система классов SQLAlchemy могла меняться, оставляя флаги здесь нетронутыми для обеспечения совместимости.

attribute sqlalchemy.orm.InspectionAttr.extension_type: InspectionAttrExtensionType = 'not_extension'¶: Тип расширения, если таковой имеется. По умолчанию NotExtension.NOT_EXTENSION.

См.также

HybridExtensionType

AssociationProxyExtensionType

attribute sqlalchemy.orm.InspectionAttr.is_aliased_class = False¶: True, если этот объект является экземпляром AliasedClass.

attribute sqlalchemy.orm.InspectionAttr.is_attribute = False¶

True, если этот объект является Python descriptor.

Это может относиться к одному из многих типов. Обычно это QueryableAttribute, который обрабатывает события атрибутов от имени MapperProperty. Но также может быть типом расширения, таким как AssociationProxy или hybrid_property. InspectionAttr.extension_type будет ссылаться на константу, идентифицирующую конкретный подтип.

См.также

attribute sqlalchemy.orm.InspectionAttr.is_bundle = False¶: True, если этот объект является экземпляром Bundle.

attribute sqlalchemy.orm.InspectionAttr.is_clause_element = False¶: True, если этот объект является экземпляром ClauseElement.

attribute sqlalchemy.orm.InspectionAttr.is_instance = False¶: True, если этот объект является экземпляром InstanceState.

attribute sqlalchemy.orm.InspectionAttr.is_mapper = False¶: True, если этот объект является экземпляром Mapper.

attribute sqlalchemy.orm.InspectionAttr.is_property = False¶: True, если этот объект является экземпляром MapperProperty.

attribute sqlalchemy.orm.InspectionAttr.is_selectable = False¶: Возвращает True, если этот объект является экземпляром Selectable.

class sqlalchemy.orm.InspectionAttrInfo¶

Добавляет атрибут .info к InspectionAttr.

Обоснование для InspectionAttr в сравнении с InspectionAttrInfo заключается в том, что первый совместим как миксин для классов, которые определяют __slots__; по сути, это артефакт реализации.

Members

info

Классная подпись

класс sqlalchemy.orm.InspectionAttrInfo (sqlalchemy.orm.base.InspectionAttr)

attribute sqlalchemy.orm.InspectionAttrInfo.info¶

Информационный словарь, связанный с объектом, позволяющий связать пользовательские данные с этим InspectionAttr.

Словарь создается при первом обращении к нему. В качестве альтернативы он может быть указан как аргумент конструктора функций column_property(), relationship() или composite().

См.также

QueryableAttribute.info

Проверка сопоставленных экземпляров

class sqlalchemy.orm.InstanceState¶

отслеживает информацию о состоянии на уровне экземпляра.

InstanceState - это ключевой объект, используемый SQLAlchemy ORM для отслеживания состояния объекта; он создается в момент инстанцирования объекта, обычно в результате instrumentation, который SQLAlchemy применяет к методу __init__() класса.

InstanceState также является полупубличным объектом, доступным для проверки состояния сопоставленного экземпляра во время выполнения, включая такую информацию, как его текущий статус в рамках конкретного Session и подробности о данных по отдельным атрибутам. Публичный API для получения объекта InstanceState заключается в использовании системы inspect():

>>> from sqlalchemy import inspect
>>> insp = inspect(some_mapped_object)
>>> insp.attrs.nickname.history
History(added=['new nickname'], unchanged=(), deleted=['nickname'])

См.также

Классная подпись

класс sqlalchemy.orm.InstanceState (sqlalchemy.orm.base.InspectionAttrInfo, typing.Generic)

attribute sqlalchemy.orm.InstanceState.async_session¶

Возвращает владельца AsyncSession для данного экземпляра, или None, если таковых нет.

Этот атрибут не является не-None, только если для данного объекта ORM используется API sqlalchemy.ext.asyncio. Возвращаемый объект AsyncSession будет прокси для объекта Session, который будет возвращен из атрибута InstanceState.session для данного InstanceState.

Добавлено в версии 1.4.18.

См.также

Асинхронный ввод/вывод (asyncio)

attribute sqlalchemy.orm.InstanceState.attrs¶

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

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

attribute sqlalchemy.orm.InstanceState.callables: Dict[str, Callable[[InstanceState[_O], PassiveFlag], Any]] = {}¶

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

В SQLAlchemy 1.0 это используется только для ленивых загрузчиков / отложенных загрузчиков, которые были настроены через опцию запроса.

Ранее callables использовался также для указания истекших атрибутов путем хранения в этом словаре ссылки на сам InstanceState. Теперь эту роль выполняет набор expired_attributes.

attribute sqlalchemy.orm.InstanceState.deleted¶

Возвращает True, если объект является deleted.

Объект, находящийся в удаленном состоянии, гарантированно не будет находиться в пределах Session.identity_map своего родителя Session; однако если транзакция сессии будет откачена, объект будет восстановлен в постоянном состоянии и карте идентификации.

Примечание

Атрибут InstanceState.deleted относится к определенному состоянию объекта, которое возникает между состояниями «persistent» и «detached»; как только объект становится detached, атрибут InstanceState.deleted не возвращает True; чтобы определить, что состояние было удалено, независимо от того, связан ли объект с Session, используйте аксессор InstanceState.was_deleted.

См.также

Краткое введение в состояния объектов

attribute sqlalchemy.orm.InstanceState.detached¶: Возвращает True, если объект является detached.

См.также

Краткое введение в состояния объектов

attribute sqlalchemy.orm.InstanceState.dict¶

Возвращает дикту экземпляра, используемого объектом.

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

В случае, если реальный объект был собран в мусор, этот аксессор возвращает пустой словарь.

attribute sqlalchemy.orm.InstanceState.expired_attributes: Set[str]¶

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

см. также коллекцию unmodified, которая пересекается с этим набором, когда происходит операция обновления.

attribute sqlalchemy.orm.InstanceState.has_identity¶

Возвращает True, если у этого объекта есть ключ идентификации.

Это значение всегда должно совпадать с выражением state.persistent или state.detached.

attribute sqlalchemy.orm.InstanceState.identity¶

Возвращает сопоставленный идентификатор сопоставленного объекта. Это идентификатор первичного ключа, сохраненный ORM, который всегда может быть передан непосредственно в Query.get().

Возвращает None, если объект не имеет идентификатора первичного ключа.

Примечание

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

attribute sqlalchemy.orm.InstanceState.identity_key¶

Возвращает идентификационный ключ для сопоставленного объекта.

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

attribute sqlalchemy.orm.InstanceState.is_instance: bool = True¶: True, если этот объект является экземпляром InstanceState.

attribute sqlalchemy.orm.InstanceState.mapper¶: Возвращает Mapper, используемый для данного сопоставленного объекта.

attribute sqlalchemy.orm.InstanceState.object¶

Возвращает отображенный объект, представленный данным InstanceState.

Возвращает None, если объект был собран.

attribute sqlalchemy.orm.InstanceState.pending¶: Возвращает True, если объект является pending.

См.также

Краткое введение в состояния объектов

attribute sqlalchemy.orm.InstanceState.persistent¶

Возвращает True, если объект является persistent.

Объект, находящийся в постоянном состоянии, гарантированно находится в пределах Session.identity_map своего родителя Session.

См.также

Краткое введение в состояния объектов

attribute sqlalchemy.orm.InstanceState.session¶

Возвращает владельца Session для данного экземпляра, или None, если таковых нет.

Обратите внимание, что в некоторых случаях результат может быть отличным от результата obj in session; объект, который был удален, будет сообщать, что он не in session, однако если транзакция все еще выполняется, этот атрибут все еще будет ссылаться на эту сессию. Только после завершения транзакции объект становится полностью отделенным при нормальных обстоятельствах.

См.также

InstanceState.async_session

attribute sqlalchemy.orm.InstanceState.transient¶: Возвращает True, если объект является transient.

См.также

Краткое введение в состояния объектов

attribute sqlalchemy.orm.InstanceState.unloaded¶

Возвращает набор ключей, у которых нет загруженного значения.

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

attribute sqlalchemy.orm.InstanceState.unloaded_expirable¶

Синоним InstanceState.unloaded.

Не рекомендуется, начиная с версии 2.0: Атрибут InstanceState.unloaded_expirable является устаревшим. Пожалуйста, используйте InstanceState.unloaded.

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

attribute sqlalchemy.orm.InstanceState.unmodified¶: Возвращает набор ключей, у которых нет незафиксированных изменений

method sqlalchemy.orm.InstanceState.unmodified_intersection(keys: Iterable[str]) → Set[str]¶: Возвращаем self.unmodified.intersection(keys).

attribute sqlalchemy.orm.InstanceState.was_deleted¶

Возвращает True, если этот объект находится или ранее находился в состоянии «deleted» и не был возвращен в состояние persistent.

Этот флаг возвращает значение True, если объект был удален в режиме flush. Когда объект будет удален из сессии явно или через фиксацию транзакции и перейдет в состояние «detached», этот флаг будет продолжать сообщать True.

См.также

InstanceState.deleted - относится к состоянию «удалено»

was_deleted() - автономная функция

Краткое введение в состояния объектов

class sqlalchemy.orm.InstrumentedAttribute¶: Базовый класс для объектов descriptor, которые перехватывают события атрибутов от имени объекта MapperProperty. Собственно MapperProperty доступен через атрибут QueryableAttribute.property.

См.также

InstrumentedAttribute

MapperProperty

Mapper.all_orm_descriptors

Mapper.attrs

Классная подпись

класс sqlalchemy.orm.InstrumentedAttribute (sqlalchemy.orm.QueryableAttribute)

class sqlalchemy.orm.LoaderCallableStatus¶

Перечисление.

Members

ATTR_EMPTY, ATTR_WAS_SET, NEVER_SET, NO_VALUE, PASSIVE_CLASS_MISMATCH, PASSIVE_NO_RESULT

Классная подпись

класс sqlalchemy.orm.LoaderCallableStatus (enum.Enum)

attribute sqlalchemy.orm.LoaderCallableStatus.ATTR_EMPTY = 3¶: Символ, используемый на внутреннем уровне для указания того, что атрибут не имеет возможности вызова.

attribute sqlalchemy.orm.LoaderCallableStatus.ATTR_WAS_SET = 2¶: Символ, возвращаемый вызываемой программой-загрузчиком, указывающий на то, что полученное значение или значения были присвоены своим атрибутам на целевом объекте.

attribute sqlalchemy.orm.LoaderCallableStatus.NEVER_SET = 4¶: Синоним NO_VALUE

Изменено в версии 1.4: NEVER_SET был объединен с NO_VALUE

attribute sqlalchemy.orm.LoaderCallableStatus.NO_VALUE = 4¶: Символ, который может быть помещен в качестве «предыдущего» значения атрибута, указывая на то, что при изменении атрибута не было загружено никакого значения, и флаги указывают на то, что мы не должны его загружать.

attribute sqlalchemy.orm.LoaderCallableStatus.PASSIVE_CLASS_MISMATCH = 1¶: Символ, указывающий на то, что объект локально присутствует для данного идентификатора первичного ключа, но он не относится к запрашиваемому классу. Поэтому возвращаемое значение - None, и никакого SQL не должно выдаваться.

attribute sqlalchemy.orm.LoaderCallableStatus.PASSIVE_NO_RESULT = 0¶: Символ, возвращаемый вызываемым загрузчиком или другой операцией извлечения атрибутов/истории, когда значение не может быть определено, основываясь на флагах вызываемого загрузчика.

class sqlalchemy.orm.Mapped¶

Представляет сопоставленный атрибут ORM на сопоставленном классе.

Этот класс представляет собой полный интерфейс дескриптора для любого атрибута класса, который будет instrumented в классе ORM Mapper. Предоставляет соответствующую информацию программам проверки типов, таким как pylance и mypy, чтобы ORM-сопоставленные атрибуты были правильно типизированы.

Наиболее заметное использование Mapped - в форме Declarative Mapping конфигурации Mapper, где он используется в явном виде и управляет конфигурацией атрибутов ORM, таких как mapped_class() и relationship().

См.также

Использование декларативного базового класса

Декларативная таблица с mapped_column()

Совет

Класс Mapped представляет атрибуты, которые обрабатываются непосредственно классом Mapper. Он не включает другие классы дескрипторов Python, предоставляемые в качестве расширений, включая Атрибуты гибрида и Доверенность Ассоциации. Хотя эти системы по-прежнему используют специфичные для ORM суперклассы и структуры, они не являются instrumented классами Mapper и вместо этого предоставляют свою собственную функциональность при обращении к классу.

Добавлено в версии 1.4.

Классная подпись

class sqlalchemy.orm.Mapped (sqlalchemy.orm.base.SQLORMExpression, sqlalchemy.orm.base.ORMDescriptor, sqlalchemy.orm.base._MappedAnnotationBase, sqlalchemy.sql.roles.DDLConstraintColumnRole)

class sqlalchemy.orm.MappedColumn¶

Отображает один Column на класс.

MappedColumn является специализацией класса ColumnProperty и ориентирован на декларативную конфигурацию.

Для создания объектов MappedColumn используйте функцию конструктора mapped_column().

Добавлено в версии 2.0.

Классная подпись

class sqlalchemy.orm.MappedColumn (sqlalchemy.orm._IntrospectsAnnotations, sqlalchemy.orm._MapsColumns, sqlalchemy.orm.base._DeclarativeMapped)

class sqlalchemy.orm.MapperProperty¶

Представляют определенный атрибут класса, отображаемый с помощью Mapper.

Наиболее распространенными встречами MapperProperty являются отображение Column, которое представлено в отображении как экземпляр ColumnProperty, и ссылка на другой класс, созданный relationship(), представленный в отображении как экземпляр Relationship.

Members

cascade_iterator(), class_attribute, comparator, create_row_processor(), do_init(), doc, info, init(), instrument_class(), is_property, key, merge(), parent, post_instrument_class(), set_parent(), setup()

Классная подпись

class sqlalchemy.orm.MapperProperty (sqlalchemy.sql.cache_key.HasCacheKey, sqlalchemy.orm._DCAttributeOptions, sqlalchemy.orm.base._MappedAttribute, sqlalchemy.orm.base.InspectionAttrInfo, sqlalchemy.util.langhelpers.MemoizedSlots)

method sqlalchemy.orm.MapperProperty.cascade_iterator(type_: str, state: InstanceState[Any], dict_: _InstanceDict, visited_states: Set[InstanceState[Any]], halt_on: Optional[Callable[[InstanceState[Any]], bool]] = None) → Iterator[Tuple[object, Mapper[Any], InstanceState[Any], _InstanceDict]]¶

Итерация по экземплярам, связанным с данным экземпляром для определенного «каскада», начиная с данного MapperProperty.

Возвращает итератор3-кортежей (экземпляр, картограф, состояние).

Обратите внимание, что коллекция „cascade“ на этом MapperProperty сначала проверяется на данный тип перед вызовом cascade_iterator.

Этот метод обычно применяется только к Отношениям.

attribute sqlalchemy.orm.MapperProperty.class_attribute¶

Возвращает связанный с классом дескриптор, соответствующий данному MapperProperty.

По сути, это вызов getattr():

return getattr(self.parent.class_, self.key)

Т.е. если этот MapperProperty был назван addresses, а класс, с которым он сопоставлен - User, то возможна такая последовательность:

>>> from sqlalchemy import inspect
>>> mapper = inspect(User)
>>> addresses_property = mapper.attrs.addresses
>>> addresses_property.class_attribute is User.addresses
True
>>> User.addresses.property is addresses_property
True

attribute sqlalchemy.orm.MapperProperty.comparator: PropComparator[_T]¶: Экземпляр PropComparator, который реализует построение SQL-выражения от имени этого сопоставленного атрибута.

method sqlalchemy.orm.MapperProperty.create_row_processor(context: ORMCompileState, query_entity: _MapperEntity, path: AbstractEntityRegistry, mapper: Mapper[Any], result: Result[Any], adapter: Optional[ORMAdapter], populators: _PopulatorDict) → None¶: Производить функции обработки строк и добавлять их к заданному набору списков популяторов.

method sqlalchemy.orm.MapperProperty.do_init() → None¶

Выполните шаги инициализации, специфичные для подклассов, после создания картографа.

Это шаблонный метод, вызываемый методом init() объекта MapperProperty.

attribute sqlalchemy.orm.MapperProperty.doc: Optional[str]¶: необязательная строка документации

attribute sqlalchemy.orm.MapperProperty.info: _InfoType¶

Информационный словарь, связанный с объектом, позволяющий связать пользовательские данные с этим InspectionAttr.

См.также

QueryableAttribute.info

Повторное выполнение заявлений

method sqlalchemy.orm.MapperProperty.init() → None¶: Вызывается после создания всех картографов, чтобы собрать отношения между картографами и выполнить другие шаги инициализации после создания картографа.

method sqlalchemy.orm.MapperProperty.instrument_class(mapper: Mapper[Any]) → None¶

Здесь MapperProperty обычно обращается к модулю атрибутов для установки InstrumentedAttribute.

attribute sqlalchemy.orm.MapperProperty.is_property = True¶: Часть интерфейса InspectionAttr; указывает, что этот объект является свойством картографа.

attribute sqlalchemy.orm.MapperProperty.key: str¶: имя атрибута класса

method sqlalchemy.orm.MapperProperty.merge(session: Session, source_state: InstanceState[Any], source_dict: _InstanceDict, dest_state: InstanceState[Any], dest_dict: _InstanceDict, load: bool, _recursive: Dict[Any, object], _resolve_conflict_map: Dict[_IdentityKeyType[Any], object]) → None¶: Объединить атрибут, представленный этим MapperProperty, с объектом-источником и объектом-получателем.

attribute sqlalchemy.orm.MapperProperty.parent: Mapper[Any]¶: Mapper, управляющий этим свойством.

method sqlalchemy.orm.MapperProperty.post_instrument_class(mapper: Mapper[Any]) → None¶

Выполните настройки инструментария, которые необходимо выполнить после завершения init().

Данный Mapper - это Mapper, вызывающий операцию, который может быть не тем же Mapper, что и self.parent в сценарии наследования; однако, Mapper всегда будет, по крайней мере, подмаппером self.parent.

Этот метод обычно используется StrategizedProperty, который делегирует его LoaderStrategy.init_class_attribute() для выполнения окончательной настройки связанного с классом InstrumentedAttribute.

method sqlalchemy.orm.MapperProperty.set_parent(parent: Mapper[Any], init: bool) → None¶

Установите родительский маппер, который ссылается на этот MapperProperty.

Этот метод переопределяется некоторыми подклассами для выполнения дополнительной настройки при первом знакомстве с картографом.

method sqlalchemy.orm.MapperProperty.setup(context: ORMCompileState, query_entity: _MapperEntity, path: AbstractEntityRegistry, adapter: Optional[ORMAdapter], **kwargs: Any) → None¶

Вызывается Query для построения SQL-оператора.

Каждый MapperProperty, связанный с целевым маппером, обрабатывает утверждение, на которое ссылается контекст запроса, добавляя столбцы и/или критерий по мере необходимости.

class sqlalchemy.orm.MappedSQLExpression¶

Декларативный внешний интерфейс для класса ColumnProperty.

Публичный конструктор - это функция column_property().

Изменено в версии 2.0: Добавлен MappedSQLExpression в качестве подкласса, совместимого с декларативным методом, для ColumnProperty.

См.также

MappedColumn

Классная подпись

класс sqlalchemy.orm.MappedSQLExpression (sqlalchemy.orm.properties.ColumnProperty, sqlalchemy.orm.base._DeclarativeMapped)

class sqlalchemy.orm.InspectionAttrExtensionType¶: Символы, указывающие на тип расширения, частью которого является InspectionAttr.

Классная подпись

класс sqlalchemy.orm.InspectionAttrExtensionType (enum.Enum)

class sqlalchemy.orm.NotExtension¶

Перечисление.

Members

NOT_EXTENSION

Классная подпись

класс sqlalchemy.orm.NotExtension (sqlalchemy.orm.base.InspectionAttrExtensionType)

attribute sqlalchemy.orm.NotExtension.NOT_EXTENSION = 'not_extension'¶

Символ, указывающий на InspectionAttr, который не является частью sqlalchemy.ext.

Присваивается атрибуту InspectionAttr.extension_type.

function sqlalchemy.orm.merge_result(query: Query[Any], iterator: Union[FrozenResult, Iterable[Sequence[Any]], Iterable[object]], load: bool = True) → Union[FrozenResult, Iterable[Any]]¶

Объединить результат в сессию данного объекта Query.

Не рекомендуется, начиная с версии 2.0: Функция merge_result() считается унаследованной от серии 1.x SQLAlchemy и становится унаследованной конструкцией в версии 2.0. Функция, как и метод на Query, вытесняется функцией merge_frozen_result(). (Справочная информация по SQLAlchemy 2.0 в: SQLAlchemy 2.0 - руководство по миграции)

Документацию верхнего уровня по этой функции смотрите в Query.merge_result().

function sqlalchemy.orm.merge_frozen_result(session, statement, frozen_result, load=True)¶

Объединить FrozenResult обратно в Session, возвращая новый объект Result с объектами persistent.

Пример см. в разделе Повторное выполнение заявлений.

См.также

Result.freeze()

FrozenResult

class sqlalchemy.orm.PropComparator¶

Определяет операции SQL для сопоставленных атрибутов ORM.

SQLAlchemy позволяет переопределять операторы как на уровне Core, так и на уровне ORM. PropComparator является базовым классом переопределения операторов для операций уровня ORM, включая операции ColumnProperty, Relationship и Composite.

Можно создавать определяемые пользователем подклассы PropComparator. Встроенные методы операторов сравнения и математических операторов Python, такие как ColumnOperators.__eq__(), ColumnOperators.__lt__() и ColumnOperators.__add__(), могут быть переопределены для обеспечения нового поведения оператора. Пользовательский PropComparator передается экземпляру MapperProperty через аргумент comparator_factory. В каждом случае следует использовать соответствующий подкласс PropComparator:

# definition of custom PropComparator subclasses

from sqlalchemy.orm.properties import \
                        ColumnProperty,\
                        Composite,\
                        Relationship

class MyColumnComparator(ColumnProperty.Comparator):
    def __eq__(self, other):
        return self.__clause_element__() == other

class MyRelationshipComparator(Relationship.Comparator):
    def any(self, expression):
        "define the 'any' operation"
        # ...

class MyCompositeComparator(Composite.Comparator):
    def __gt__(self, other):
        "redefine the 'greater than' operation"

        return sql.and_(*[a>b for a, b in
                          zip(self.__clause_element__().clauses,
                              other.__composite_values__())])


# application of custom PropComparator subclasses

from sqlalchemy.orm import column_property, relationship, composite
from sqlalchemy import Column, String

class SomeMappedClass(Base):
    some_column = column_property(Column("some_column", String),
                        comparator_factory=MyColumnComparator)

    some_relationship = relationship(SomeOtherClass,
                        comparator_factory=MyRelationshipComparator)

    some_composite = composite(
            Column("a", String), Column("b", String),
            comparator_factory=MyCompositeComparator
        )

Обратите внимание, что для переопределения операторов на уровне столбцов обычно проще определить операторы на уровне ядра, используя атрибут TypeEngine.comparator_factory. См. раздел Переопределение и создание новых операторов для более подробной информации.

См.также

Comparator

Объединение отношений с пользовательскими критериями ON

Классная подпись

class sqlalchemy.orm.PropComparator (sqlalchemy.orm.base.SQLORMOperations, typing.Generic, sqlalchemy.sql.expression.ColumnOperators)

method sqlalchemy.orm.PropComparator.__eq__(other: Any) → ColumnOperators¶

наследуется от sqlalchemy.sql.expression.ColumnOperators.__eq__ метода ColumnOperators

Реализуйте оператор ==.

В контексте столбца выдает предложение a = b. Если цель None, выдает a IS NULL.

method sqlalchemy.orm.PropComparator.__le__(other: Any) → ColumnOperators¶

наследуется от sqlalchemy.sql.expression.ColumnOperators.__le__ метода ColumnOperators

Реализуйте оператор <=.

В контексте столбца производит предложение a <= b.

method sqlalchemy.orm.PropComparator.__lt__(other: Any) → ColumnOperators¶

наследуется от sqlalchemy.sql.expression.ColumnOperators.__lt__ метода ColumnOperators

Реализуйте оператор <.

В контексте столбца производит предложение a < b.

method sqlalchemy.orm.PropComparator.__ne__(other: Any) → ColumnOperators¶

наследуется от sqlalchemy.sql.expression.ColumnOperators.__ne__ метода ColumnOperators

Реализуйте оператор !=.

В контексте столбца выдает предложение a != b. Если цель None, выдает a IS NOT NULL.

method sqlalchemy.orm.PropComparator.adapt_to_entity(adapt_to_entity: AliasedInsp[Any]) → PropComparator[_T]¶: Возвращает копию этого PropComparator, который будет использовать заданные AliasedInsp для получения соответствующих выражений.

attribute sqlalchemy.orm.PropComparator.adapter¶: Создайте вызываемую программу, которая адаптирует выражения столбцов к псевдослучайной версии этого компаратора.

method sqlalchemy.orm.PropComparator.all_() → ColumnOperators¶

наследуется от ColumnOperators.all_() метода ColumnOperators

Произведите предложение all_() против родительского объекта.

Примеры см. в документации для all_().

Примечание

не путайте более новый метод ColumnOperators.all_() с его более старым аналогом ARRAY, специфическим методом Comparator.all(), который имеет другой синтаксис вызова и схему использования.

method sqlalchemy.orm.PropComparator.and_(*criteria: _ColumnExpressionArgument[bool]) → PropComparator[bool]¶

Добавьте дополнительные критерии к предложению ON, которое представлено этим атрибутом отношения.

Например:

stmt = select(User).join(
    User.addresses.and_(Address.email_address != 'foo')
)

stmt = select(User).options(
    joinedload(User.addresses.and_(Address.email_address != 'foo'))
)

Добавлено в версии 1.4.

См.также

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

with_loader_criteria()

method sqlalchemy.orm.PropComparator.any(criterion: Optional[_ColumnExpressionArgument[bool]] = None, **kwargs: Any) → ColumnElement[bool]¶

Возвращает SQL-выражение, представляющее true, если этот элемент ссылается на член, удовлетворяющий заданному критерию.

Обычная реализация any() - это Comparator.any().

Параметры:

criterion – необязательный ClauseElement, сформулированный относительно таблицы или атрибутов класса-члена.
**kwargs – пары ключ/значение, соответствующие именам атрибутов класса-члена, которые будут сравниваться через равенство с соответствующими значениями.

method sqlalchemy.orm.PropComparator.any_() → ColumnOperators¶

наследуется от ColumnOperators.any_() метода ColumnOperators

Произведите предложение any_() против родительского объекта.

Примеры см. в документации для any_().

Примечание

не путайте более новый метод ColumnOperators.any_() с его более старым аналогом ARRAY, специфическим методом Comparator.any(), который имеет другой синтаксис вызова и схему использования.

method sqlalchemy.orm.PropComparator.asc() → ColumnOperators¶: наследуется от ColumnOperators.asc() метода ColumnOperators

Произведите предложение asc() против родительского объекта.

method sqlalchemy.orm.PropComparator.between(cleft: Any, cright: Any, symmetric: bool = False) → ColumnOperators¶: наследуется от ColumnOperators.between() метода ColumnOperators

Произведите предложение between() против родительского объекта, задав нижний и верхний диапазон.

method sqlalchemy.orm.PropComparator.bitwise_and(other: Any) → ColumnOperators¶: наследуется от ColumnOperators.bitwise_and() метода ColumnOperators

Произвести побитовую операцию AND, обычно с помощью оператора &.

Добавлено в версии 2.0.2.

См.также

Побитовые операторы

method sqlalchemy.orm.PropComparator.bitwise_lshift(other: Any) → ColumnOperators¶: наследуется от ColumnOperators.bitwise_lshift() метода ColumnOperators

Произвести побитовую операцию LSHIFT, обычно с помощью оператора <<.

Добавлено в версии 2.0.2.

См.также

Побитовые операторы

method sqlalchemy.orm.PropComparator.bitwise_not() → ColumnOperators¶: наследуется от ColumnOperators.bitwise_not() метода ColumnOperators

Произвести побитовую операцию NOT, обычно с помощью оператора ~.

Добавлено в версии 2.0.2.

См.также

Побитовые операторы

method sqlalchemy.orm.PropComparator.bitwise_or(other: Any) → ColumnOperators¶: наследуется от ColumnOperators.bitwise_or() метода ColumnOperators

Произвести операцию побитового ИЛИ, обычно с помощью оператора |.

Добавлено в версии 2.0.2.

См.также

Побитовые операторы

method sqlalchemy.orm.PropComparator.bitwise_rshift(other: Any) → ColumnOperators¶: наследуется от ColumnOperators.bitwise_rshift() метода ColumnOperators

Произвести побитовую операцию RSHIFT, обычно с помощью оператора >>.

Добавлено в версии 2.0.2.

См.также

Побитовые операторы

method sqlalchemy.orm.PropComparator.bitwise_xor(other: Any) → ColumnOperators¶: наследуется от ColumnOperators.bitwise_xor() метода ColumnOperators

Произвести побитовую операцию XOR, обычно с помощью оператора ^ или # для PostgreSQL.

Добавлено в версии 2.0.2.

См.также

Побитовые операторы

method sqlalchemy.orm.PropComparator.bool_op(opstring: str, precedence: int = 0, python_impl: Optional[Callable[[...], Any]] = None) → Callable[[Any], Operators]¶

наследуется от Operators.bool_op() метода Operators

Возвращает пользовательский булев оператор.

Этот метод является сокращением для вызова Operators.op() и передачи флага Operators.op.is_comparison со значением True. Ключевым преимуществом использования Operators.bool_op() является то, что при использовании конструкций столбцов «булева» природа возвращаемого выражения будет присутствовать для целей PEP 484.

См.также

Operators.op()

method sqlalchemy.orm.PropComparator.collate(collation: str) → ColumnOperators¶: наследуется от ColumnOperators.collate() метода ColumnOperators

Производит предложение collate() против родительского объекта, учитывая строку collation.

См.также

collate()

method sqlalchemy.orm.PropComparator.concat(other: Any) → ColumnOperators¶

наследуется от ColumnOperators.concat() метода ColumnOperators

Реализуйте оператор „concat“.

В контексте столбца производит предложение a || b, или использует оператор concat() в MySQL.

method sqlalchemy.orm.PropComparator.contains(other: Any, **kw: Any) → ColumnOperators¶

наследуется от ColumnOperators.contains() метода ColumnOperators

Реализуйте оператор „contains“.

Вырабатывает выражение LIKE, которое проверяет совпадение с серединой строкового значения:

column LIKE '%' || <other> || '%'

Например:

stmt = select(sometable).\
    where(sometable.c.column.contains("foobar"))

Поскольку оператор использует LIKE, символы подстановки "%" и "_", присутствующие внутри выражения <other>, также будут вести себя как символы подстановки. Для буквальных строковых значений флаг ColumnOperators.contains.autoescape может быть установлен в значение True, чтобы применить экранирование к вхождениям этих символов в строковое значение так, чтобы они совпадали сами по себе, а не как символы подстановки. В качестве альтернативы, параметр ColumnOperators.contains.escape устанавливает данный символ как символ экранирования, что может быть полезно, когда целевое выражение не является литеральной строкой.

Параметры:

other – выражение для сравнения. Обычно это обычное строковое значение, но может быть и произвольным выражением SQL. Символы подстановки LIKE % и _ по умолчанию не экранируются, если только флаг ColumnOperators.contains.autoescape не установлен в True.
autoescape – boolean; при значении True устанавливает символ экранирования в выражении LIKE, затем применяет его ко всем вхождениям "%", "_" и самого символа экранирования в значении сравнения, которое считается литеральной строкой, а не выражением SQL. Выражение типа:: somecolumn.contains(«foo%bar», autoescape=True) будет выглядеть так:: somecolumn LIKE „%“ || :param || „%“ ESCAPE „/“ Со значением :param как "foo/%bar".
escape – символ, который при передаче будет отображаться с ключевым словом ESCAPE, чтобы установить этот символ в качестве управляющего символа. Затем этот символ может быть помещен перед вхождениями % и _, чтобы позволить им действовать как самим себе, а не как символам подстановки. Выражение типа:: somecolumn.contains(«foo/%bar», escape=»^») будет выглядеть так:: somecolumn LIKE „%“ || :param || „%“ ESCAPE „^“ Параметр также может быть объединен с ColumnOperators.contains.autoescape:: somecolumn.contains(«foo%bar^bat», escape=»^», autoescape=True) Где выше, заданный литеральный параметр будет преобразован в "foo^%bar^^bat" перед передачей в базу данных.

См.также

ColumnOperators.startswith()

ColumnOperators.endswith()

ColumnOperators.startswith()

method sqlalchemy.orm.PropComparator.desc() → ColumnOperators¶: наследуется от ColumnOperators.desc() метода ColumnOperators

Произведите предложение desc() против родительского объекта.

method sqlalchemy.orm.PropComparator.distinct() → ColumnOperators¶: наследуется от ColumnOperators.distinct() метода ColumnOperators

Произведите предложение distinct() против родительского объекта.

method sqlalchemy.orm.PropComparator.endswith(other: Any, escape: Optional[str] = None, autoescape: bool = False) → ColumnOperators¶

наследуется от ColumnOperators.endswith() метода ColumnOperators

Реализуйте оператор „endswith“.

Создает выражение LIKE, которое проверяет совпадение с концом строкового значения:

column LIKE '%' || <other>

Например:

stmt = select(sometable).\
    where(sometable.c.column.endswith("foobar"))

Поскольку оператор использует LIKE, символы подстановки "%" и "_", присутствующие внутри выражения <other>, также будут вести себя как символы подстановки. Для буквальных строковых значений флаг ColumnOperators.endswith.autoescape может быть установлен в значение True, чтобы применить экранирование к вхождениям этих символов в строковое значение так, чтобы они совпадали сами по себе, а не как символы подстановки. В качестве альтернативы, параметр ColumnOperators.endswith.escape устанавливает данный символ как символ экранирования, что может быть полезно, когда целевое выражение не является литеральной строкой.

Параметры:

other – выражение для сравнения. Обычно это обычное строковое значение, но может быть и произвольным выражением SQL. Символы подстановки LIKE % и _ по умолчанию не экранируются, если только флаг ColumnOperators.endswith.autoescape не установлен в True.
autoescape – boolean; когда True, устанавливает символ экранирования в выражении LIKE, затем применяет его ко всем вхождениям "%", "_" и самого символа экранирования в значении сравнения, которое предполагается как литеральная строка, а не выражение SQL. Выражение типа:: somecolumn.endswith(«foo%bar», autoescape=True) будет выглядеть так:: somecolumn LIKE „%“ || :param ESCAPE „/“ Со значением :param как "foo/%bar".
escape – символ, который при передаче будет отображаться с ключевым словом ESCAPE, чтобы установить этот символ в качестве управляющего символа. Затем этот символ может быть помещен перед вхождениями % и _, чтобы позволить им действовать как самим себе, а не как символам подстановки. Выражение типа:: somecolumn.endswith(«foo/%bar», escape=»^») будет выглядеть так:: somecolumn LIKE „%“ || :param ESCAPE „^“ Параметр также может быть объединен с ColumnOperators.endswith.autoescape:: somecolumn.endswith(«foo%bar^bat», escape=»^», autoescape=True) Где выше, данный литеральный параметр будет преобразован в "foo^%bar^^bat" перед передачей в базу данных.

См.также

ColumnOperators.contains()

ColumnOperators.contains()

method sqlalchemy.orm.PropComparator.has(criterion: Optional[_ColumnExpressionArgument[bool]] = None, **kwargs: Any) → ColumnElement[bool]¶

Обычная реализация has() - это Comparator.has().

Параметры:

criterion – необязательный ClauseElement, сформулированный относительно таблицы или атрибутов класса-члена.
**kwargs – пары ключ/значение, соответствующие именам атрибутов класса-члена, которые будут сравниваться через равенство с соответствующими значениями.

method sqlalchemy.orm.PropComparator.icontains(other: Any, **kw: Any) → ColumnOperators¶

наследуется от ColumnOperators.icontains() метода ColumnOperators

Реализуйте оператор icontains, например, нечувствительную к регистру версию ColumnOperators.contains().

Создает выражение LIKE, которое проверяет нечувствительное соответствие для середины строкового значения:

lower(column) LIKE '%' || lower(<other>) || '%'

Например:

stmt = select(sometable).\
    where(sometable.c.column.icontains("foobar"))

Поскольку оператор использует LIKE, символы подстановки "%" и "_", присутствующие внутри выражения <other>, также будут вести себя как символы подстановки. Для буквальных строковых значений флаг ColumnOperators.icontains.autoescape может быть установлен в значение True, чтобы применить экранирование к вхождениям этих символов в строковое значение так, чтобы они совпадали сами по себе, а не как символы подстановки. В качестве альтернативы, параметр ColumnOperators.icontains.escape устанавливает данный символ как символ экранирования, что может быть полезно, когда целевое выражение не является литеральной строкой.

Параметры:

other – выражение для сравнения. Обычно это обычное строковое значение, но может быть и произвольным выражением SQL. Символы подстановки LIKE % и _ по умолчанию не экранируются, если только флаг ColumnOperators.icontains.autoescape не установлен в True.
autoescape – boolean; при значении True устанавливает символ экранирования в выражении LIKE, затем применяет его ко всем вхождениям "%", "_" и самого символа экранирования в значении сравнения, которое предполагается как литеральная строка, а не выражение SQL. Выражение типа:: somecolumn.icontains(«foo%bar», autoescape=True) будет выглядеть так:: lower(somecolumn) LIKE „%“ || lower(:param) || „%“ ESCAPE „/“ Со значением :param как "foo/%bar".
escape – символ, который при передаче будет отображаться с ключевым словом ESCAPE, чтобы установить этот символ в качестве управляющего символа. Затем этот символ может быть помещен перед вхождениями % и _, чтобы позволить им действовать как самим себе, а не как символам подстановки. Выражение типа:: somecolumn.icontains(«foo/%bar», escape=»^») будет выглядеть так:: lower(somecolumn) LIKE „%“ || lower(:param) || „%“ ESCAPE „^“ Параметр также может быть объединен с ColumnOperators.contains.autoescape:: somecolumn.icontains(«foo%bar^bat», escape=»^», autoescape=True) Где выше, заданный литеральный параметр будет преобразован в "foo^%bar^^bat" перед передачей в базу данных.

См.также

method sqlalchemy.orm.PropComparator.iendswith(other: Any, escape: Optional[str] = None, autoescape: bool = False) → ColumnOperators¶

наследуется от ColumnOperators.iendswith() метода ColumnOperators

Реализуйте оператор iendswith, например, нечувствительную к регистру версию ColumnOperators.endswith().

Создает выражение LIKE, которое проверяет нечувствительное совпадение конца строкового значения:

lower(column) LIKE '%' || lower(<other>)

Например:

stmt = select(sometable).\
    where(sometable.c.column.iendswith("foobar"))

Поскольку оператор использует LIKE, символы подстановки "%" и "_", присутствующие внутри выражения <other>, также будут вести себя как символы подстановки. Для буквальных строковых значений флаг ColumnOperators.iendswith.autoescape может быть установлен в значение True, чтобы применить экранирование к вхождениям этих символов в строковое значение так, чтобы они совпадали сами по себе, а не как символы подстановки. В качестве альтернативы, параметр ColumnOperators.iendswith.escape устанавливает данный символ как символ экранирования, что может быть полезно, когда целевое выражение не является литеральной строкой.

Параметры:

other – выражение для сравнения. Обычно это обычное строковое значение, но может быть и произвольным выражением SQL. Символы подстановки LIKE % и _ по умолчанию не экранируются, если только флаг ColumnOperators.iendswith.autoescape не установлен в True.
autoescape – boolean; при значении True устанавливает символ экранирования в выражении LIKE, затем применяет его ко всем вхождениям "%", "_" и самого символа экранирования в значении сравнения, которое предполагается как литеральная строка, а не как выражение SQL. Выражение типа:: somecolumn.iendswith(«foo%bar», autoescape=True) будет выглядеть так:: lower(somecolumn) LIKE „%“ || lower(:param) ESCAPE „/“ Со значением :param как "foo/%bar".
escape – символ, который при передаче будет отображаться с ключевым словом ESCAPE, чтобы установить этот символ в качестве управляющего символа. Затем этот символ может быть помещен перед вхождениями % и _, чтобы позволить им действовать как самим себе, а не как символам подстановки. Выражение типа:: somecolumn.iendswith(«foo/%bar», escape=»^») будет выглядеть так:: lower(somecolumn) LIKE „%“ || lower(:param) ESCAPE „^“ Параметр также может быть объединен с ColumnOperators.iendswith.autoescape:: somecolumn.endswith(«foo%bar^bat», escape=»^», autoescape=True) Где выше, заданный литеральный параметр будет преобразован в "foo^%bar^^bat" перед передачей в базу данных.

См.также

ColumnOperators.endswith()

method sqlalchemy.orm.PropComparator.ilike(other: Any, escape: Optional[str] = None) → ColumnOperators¶

наследуется от ColumnOperators.ilike() метода ColumnOperators

Реализуйте оператор ilike, например, нечувствительный к регистру LIKE.

В контексте столбца выдает выражение либо в форме:

lower(a) LIKE lower(other)

Или на бэкендах, поддерживающих оператор ILIKE:

a ILIKE other

Например:

stmt = select(sometable).\
    where(sometable.c.column.ilike("%foobar%"))

Параметры:

other – сравниваемое выражение
escape – необязательный управляющий символ, отображает ключевое слово ESCAPE, например:: somecolumn.ilike(«foo/%bar», escape=»/»)

См.также

ColumnOperators.is_not()

method sqlalchemy.orm.PropComparator.in_(other: Any) → ColumnOperators¶

наследуется от ColumnOperators.in_() метода ColumnOperators

Реализуйте оператор in.

В контексте столбца производит предложение column IN <other>.

Заданный параметр other может быть:

Список литеральных значений, например:
```
stmt.where(column.in_([1, 2, 3]))
```
В этой форме вызова список элементов преобразуется в набор связанных параметров той же длины, что и данный список:
```
WHERE COL IN (?, ?, ?)
```
Список кортежей может быть предоставлен, если сравнение производится с tuple_(), содержащим несколько выражений:
```
from sqlalchemy import tuple_
stmt.where(tuple_(col1, col2).in_([(1, 10), (2, 20), (3, 30)]))
```
Пустой список, например:
```
stmt.where(column.in_([]))
```
В этой вызывающей форме выражение выдает выражение «пустой набор». Эти выражения адаптированы для отдельных бэкендов и обычно пытаются получить пустой оператор SELECT в качестве подзапроса. Например, на SQLite это выражение выглядит так:
```
WHERE col IN (SELECT 1 FROM (SELECT 1) WHERE 1!=1)
```
Изменено в версии 1.4: пустые выражения IN теперь во всех случаях используют сгенерированный во время выполнения подзапрос SELECT.
Связанный параметр, например bindparam(), может быть использован, если он включает флаг bindparam.expanding:
```
stmt.where(column.in_(bindparam('value', expanding=True)))
```
В этой форме вызова выражение отображает специальное не-SQL выражение-заполнитель, которое выглядит так:
```
WHERE COL IN ([EXPANDING_value])
```
Это выражение-заполнитель перехватывается во время выполнения оператора и преобразуется в форму переменной номера связанного параметра, показанную ранее. Если бы оператор был выполнен как:
```
connection.execute(stmt, {"value": [1, 2, 3]})
```
Базе данных будет передан связанный параметр для каждого значения:
```
WHERE COL IN (?, ?, ?)
```
Добавлено в версии 1.2: добавлены «расширяющие» связанные параметры

Если передан пустой список, то будет выведено специальное выражение «пустой список», специфичное для используемой базы данных. Для SQLite это будет:
```
WHERE COL IN (SELECT 1 FROM (SELECT 1) WHERE 1!=1)
```
Добавлено в версии 1.3: «Расширяющиеся» связанные параметры теперь поддерживают пустые списки

конструкция select(), которая обычно является коррелированным скаляром select:

stmt.where(
    column.in_(
        select(othertable.c.y).
        where(table.c.x == othertable.c.x)
    )
)

В этой вызывающей форме ColumnOperators.in_() отображается так:

WHERE COL IN (SELECT othertable.y
FROM othertable WHERE othertable.x = table.x)

Параметры:: other – список литералов, конструкция select() или конструкция bindparam(), в которой флаг bindparam.expanding установлен в True.

method sqlalchemy.orm.PropComparator.is_(other: Any) → ColumnOperators¶

наследуется от ColumnOperators.is_() метода ColumnOperators

Реализуйте оператор IS.

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

См.также

method sqlalchemy.orm.PropComparator.is_distinct_from(other: Any) → ColumnOperators¶

наследуется от ColumnOperators.is_distinct_from() метода ColumnOperators

Реализуйте оператор IS DISTINCT FROM.

Выводит «a IS DISTINCT FROM b» на большинстве платформ; на некоторых, таких как SQLite, может выводить «a IS NOT b».

method sqlalchemy.orm.PropComparator.is_not(other: Any) → ColumnOperators¶

наследуется от ColumnOperators.is_not() метода ColumnOperators

Реализуйте оператор IS NOT.

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

Изменено в версии 1.4: Оператор is_not() переименован из isnot() в предыдущих выпусках. Предыдущее название остается доступным для обратной совместимости.

См.также

ColumnOperators.is_()

method sqlalchemy.orm.PropComparator.is_not_distinct_from(other: Any) → ColumnOperators¶

наследуется от ColumnOperators.is_not_distinct_from() метода ColumnOperators

Реализуйте оператор IS NOT DISTINCT FROM.

Выводит «a IS NOT DISTINCT FROM b» на большинстве платформ; на некоторых, таких как SQLite, может выводить «a IS b».

Изменено в версии 1.4: Оператор is_not_distinct_from() переименован из isnot_distinct_from() в предыдущих выпусках. Предыдущее название остается доступным для обратной совместимости.

method sqlalchemy.orm.PropComparator.isnot(other: Any) → ColumnOperators¶

наследуется от ColumnOperators.isnot() метода ColumnOperators

Реализуйте оператор IS NOT.

См.также

ColumnOperators.is_()

method sqlalchemy.orm.PropComparator.isnot_distinct_from(other: Any) → ColumnOperators¶

наследуется от ColumnOperators.isnot_distinct_from() метода ColumnOperators

Реализуйте оператор IS NOT DISTINCT FROM.

Выводит «a IS NOT DISTINCT FROM b» на большинстве платформ; на некоторых, таких как SQLite, может выводить «a IS b».

method sqlalchemy.orm.PropComparator.istartswith(other: Any, escape: Optional[str] = None, autoescape: bool = False) → ColumnOperators¶

наследуется от ColumnOperators.istartswith() метода ColumnOperators

Реализуйте оператор istartswith, например, нечувствительную к регистру версию ColumnOperators.startswith().

Создает выражение LIKE, которое проверяет нечувствительное совпадение начала строкового значения:

lower(column) LIKE lower(<other>) || '%'

Например:

stmt = select(sometable).\
    where(sometable.c.column.istartswith("foobar"))

Поскольку оператор использует LIKE, символы подстановки "%" и "_", присутствующие внутри выражения <other>, также будут вести себя как символы подстановки. Для буквальных строковых значений флаг ColumnOperators.istartswith.autoescape может быть установлен в значение True, чтобы применить экранирование к вхождениям этих символов в строковое значение так, чтобы они совпадали сами по себе, а не как символы подстановки. В качестве альтернативы, параметр ColumnOperators.istartswith.escape устанавливает данный символ как символ экранирования, что может быть полезно, когда целевое выражение не является литеральной строкой.

Параметры:

other – выражение для сравнения. Обычно это обычное строковое значение, но может быть и произвольным выражением SQL. Символы подстановки LIKE % и _ по умолчанию не экранируются, если только флаг ColumnOperators.istartswith.autoescape не установлен в True.
autoescape – boolean; при значении True устанавливает символ экранирования в выражении LIKE, затем применяет его ко всем вхождениям "%", "_" и самого символа экранирования в значении сравнения, которое предполагается как литеральная строка, а не выражение SQL. Выражение типа:: somecolumn.istartswith(«foo%bar», autoescape=True) будет выглядеть так:: lower(somecolumn) LIKE lower(:param) || „%“ ESCAPE „/“ Со значением :param как "foo/%bar".
escape – символ, который при передаче будет отображаться с ключевым словом ESCAPE, чтобы установить этот символ в качестве управляющего символа. Затем этот символ может быть помещен перед вхождениями % и _, чтобы позволить им действовать как самим себе, а не как символам подстановки. Выражение типа:: somecolumn.istartswith(«foo/%bar», escape=»^») будет выглядеть так:: lower(somecolumn) LIKE lower(:param) || „%“ ESCAPE „^“ Параметр также может быть объединен с ColumnOperators.istartswith.autoescape:: somecolumn.istartswith(«foo%bar^bat», escape=»^», autoescape=True) Где выше, заданный литеральный параметр будет преобразован в "foo^%bar^^bat" перед передачей в базу данных.

См.также

ColumnOperators.startswith()

method sqlalchemy.orm.PropComparator.like(other: Any, escape: Optional[str] = None) → ColumnOperators¶

наследуется от ColumnOperators.like() метода ColumnOperators

Реализуйте оператор like.

В контексте столбца выдает выражение:

a LIKE other

Например:

stmt = select(sometable).\
    where(sometable.c.column.like("%foobar%"))

Параметры:

other – сравниваемое выражение
escape – необязательный управляющий символ, отображает ключевое слово ESCAPE, например:: somecolumn.like(«foo/%bar», escape=»/»)

См.также

ColumnOperators.ilike()

method sqlalchemy.orm.PropComparator.match(other: Any, **kwargs: Any) → ColumnOperators¶

наследуется от ColumnOperators.match() метода ColumnOperators

Реализует специфический для базы данных оператор „match“.

ColumnOperators.match() пытается преобразоваться в MATCH-подобную функцию или оператор, предоставляемый бэкендом. Примеры включают:

PostgreSQL - выдает x @@ plainto_tsquery(y).

Изменено в версии 2.0: plainto_tsquery() теперь используется вместо to_tsquery() для PostgreSQL; для совместимости с другими формами смотрите Полнотекстовый поиск.
MySQL - выдает MATCH (x) AGAINST (y IN BOOLEAN MODE).

См.также

match - специфическая для MySQL конструкция с дополнительными возможностями.
Oracle - выдает CONTAINS(x, y).
другие бэкенды могут предоставлять специальные реализации.
Бэкенды без специальной реализации будут выдавать оператор как «MATCH». Это совместимо, например, с SQLite.

method sqlalchemy.orm.PropComparator.not_ilike(other: Any, escape: Optional[str] = None) → ColumnOperators¶

наследуется от ColumnOperators.not_ilike() метода ColumnOperators

реализовать оператор NOT ILIKE.

Это эквивалентно использованию отрицания с ColumnOperators.ilike(), то есть ~x.ilike(y).

Изменено в версии 1.4: Оператор not_ilike() переименован из notilike() в предыдущих выпусках. Предыдущее название остается доступным для обратной совместимости.

См.также

ColumnOperators.ilike()

method sqlalchemy.orm.PropComparator.not_in(other: Any) → ColumnOperators¶

наследуется от ColumnOperators.not_in() метода ColumnOperators

реализовать оператор NOT IN.

Это эквивалентно использованию отрицания с ColumnOperators.in_(), то есть ~x.in_(y).

В случае, если other является пустой последовательностью, компилятор выдает выражение «пусто не в». По умолчанию это выражение «1 = 1», которое во всех случаях выдает true. Для изменения этого поведения можно использовать create_engine.empty_in_strategy.

Изменено в версии 1.4: Оператор not_in() переименован из notin_() в предыдущих выпусках. Предыдущее название остается доступным для обратной совместимости.

Изменено в версии 1.2: Операторы ColumnOperators.in_() и ColumnOperators.not_in() теперь по умолчанию выдают «статическое» выражение для пустой последовательности IN.

См.также

ColumnOperators.in_()

method sqlalchemy.orm.PropComparator.not_like(other: Any, escape: Optional[str] = None) → ColumnOperators¶

наследуется от ColumnOperators.not_like() метода ColumnOperators

реализовать оператор NOT LIKE.

Это эквивалентно использованию отрицания с ColumnOperators.like(), то есть ~x.like(y).

Изменено в версии 1.4: Оператор not_like() переименован из notlike() в предыдущих выпусках. Предыдущее название остается доступным для обратной совместимости.

См.также

ColumnOperators.ilike()

method sqlalchemy.orm.PropComparator.notilike(other: Any, escape: Optional[str] = None) → ColumnOperators¶

наследуется от ColumnOperators.notilike() метода ColumnOperators

реализовать оператор NOT ILIKE.

Это эквивалентно использованию отрицания с ColumnOperators.ilike(), то есть ~x.ilike(y).

См.также

method sqlalchemy.orm.PropComparator.notin_(other: Any) → ColumnOperators¶

наследуется от ColumnOperators.notin_() метода ColumnOperators

реализовать оператор NOT IN.

Это эквивалентно использованию отрицания с ColumnOperators.in_(), то есть ~x.in_(y).

См.также

ColumnOperators.in_()

method sqlalchemy.orm.PropComparator.notlike(other: Any, escape: Optional[str] = None) → ColumnOperators¶

наследуется от ColumnOperators.notlike() метода ColumnOperators

реализовать оператор NOT LIKE.

Это эквивалентно использованию отрицания с ColumnOperators.like(), то есть ~x.like(y).

См.также

Использование Relationship для объединения смежных целей - в Руководство по составлению запросов в ORM

method sqlalchemy.orm.PropComparator.nulls_first() → ColumnOperators¶: наследуется от ColumnOperators.nulls_first() метода ColumnOperators

Произведите предложение nulls_first() против родительского объекта.

Изменено в версии 1.4: Оператор nulls_first() переименован из nullsfirst() в предыдущих выпусках. Предыдущее название остается доступным для обратной совместимости.

method sqlalchemy.orm.PropComparator.nulls_last() → ColumnOperators¶: наследуется от ColumnOperators.nulls_last() метода ColumnOperators

Произведите предложение nulls_last() против родительского объекта.

Изменено в версии 1.4: Оператор nulls_last() переименован из nullslast() в предыдущих выпусках. Предыдущее название остается доступным для обратной совместимости.

method sqlalchemy.orm.PropComparator.nullsfirst() → ColumnOperators¶: наследуется от ColumnOperators.nullsfirst() метода ColumnOperators

Произведите предложение nulls_first() против родительского объекта.

Изменено в версии 1.4: Оператор nulls_first() переименован из nullsfirst() в предыдущих выпусках. Предыдущее название остается доступным для обратной совместимости.

method sqlalchemy.orm.PropComparator.nullslast() → ColumnOperators¶: наследуется от ColumnOperators.nullslast() метода ColumnOperators

Произведите предложение nulls_last() против родительского объекта.

Изменено в версии 1.4: Оператор nulls_last() переименован из nullslast() в предыдущих выпусках. Предыдущее название остается доступным для обратной совместимости.

method sqlalchemy.orm.PropComparator.of_type(class_: _EntityType[Any]) → PropComparator[_T]¶

Переопределите этот объект в терминах полиморфного подкласса, конструкции with_polymorphic() или конструкции aliased().

Возвращает новый PropComparator, на основе которого может быть оценен дальнейший критерий.

например:

query.join(Company.employees.of_type(Engineer)).\
   filter(Engineer.name=='foo')

Параметры:: class_ – класс или маппер, указывающий, что критерий будет применяться к данному конкретному подклассу.

См.также

Присоединение к определенным подтипам или сущностям with_polymorphic()

method sqlalchemy.orm.PropComparator.op(opstring: str, precedence: int = 0, is_comparison: bool = False, return_type: Optional[Union[Type[TypeEngine[Any]], TypeEngine[Any]]] = None, python_impl: Optional[Callable[..., Any]] = None) → Callable[[Any], Operators]¶

наследуется от Operators.op() метода Operators

Произведите общую операторную функцию.

например:

somecolumn.op("*")(5)

производит:

somecolumn * 5

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

somecolumn.op('&')(0xff)

является побитовым И из значения в somecolumn.

Параметры:

opstring – строка, которая будет выведена в качестве инфиксного оператора между этим элементом и выражением, переданным в генерируемую функцию.
precedence – приоритет, который, как ожидается, будет применяться базой данных к оператору в выражениях SQL. Это целочисленное значение служит подсказкой для компилятора SQL, чтобы понять, когда вокруг конкретной операции следует поставить явную скобку. Меньшее число приводит к тому, что выражение будет заключено в скобки, когда оно применяется к другому оператору с более высоким приоритетом. Значение по умолчанию 0 ниже всех операторов, кроме операторов запятой (,) и AS. Значение 100 будет выше или равно всем операторам, а -100 будет ниже или равно всем операторам. … см. также:: Я использую op() для генерации пользовательского оператора, и мои скобки выходят неправильно - подробное описание того, как SQL-компилятор SQLAlchemy отображает круглые скобки
is_comparison – legacy; если True, оператор будет рассматриваться как оператор «сравнения», то есть оцениваться в булево значение true/false, как ==, > и т.д. Этот флаг предусмотрен для того, чтобы ORM-отношения могли установить, что оператор является оператором сравнения, когда он используется в пользовательском условии объединения. Использование параметра is_comparison заменяется использованием метода Operators.bool_op(); этот более лаконичный оператор устанавливает этот параметр автоматически, а также обеспечивает правильную поддержку типа PEP 484, поскольку возвращаемый объект будет выражать тип данных «boolean», т.е. BinaryExpression[bool].
return_type – класс или объект TypeEngine, который заставит возвращаемый тип выражения, создаваемого этим оператором, быть этого типа. По умолчанию операторы, указывающие Operators.op.is_comparison, преобразуются в Boolean, а те, которые не указывают, будут иметь тот же тип, что и левый операнд.
python_impl – необязательная функция Python, которая может оценить два значения Python таким же образом, как этот оператор работает при запуске на сервере базы данных. Используется для функций оценки SQL-выражений in-Python, например, для гибридных атрибутов ORM, а также для «оценщика» ORM, используемого для сопоставления объектов в сессии после многорядного обновления или удаления. например:: >>> expr = column(„x“).op(„+“, python_impl=lambda a, b: a + b)(„y“) Оператор для приведенного выше выражения будет также работать для не-SQL левых и правых объектов:: >>> expr.operator(5, 10) 15 … versionadded:: 2.0

См.также

Operators.bool_op()

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

method sqlalchemy.orm.PropComparator.operate(op: OperatorType, *other: Any, **kwargs: Any) → Operators¶

наследуется от Operators.operate() метода Operators

Оперировать с аргументом.

Это самый низкий уровень работы, по умолчанию поднимает NotImplementedError.

class MyComparator(ColumnOperators):
    def operate(self, op, other, **kwargs):
        return op(func.lower(self), func.lower(other), **kwargs)

Параметры:

op – Вызов оператора.
*other – «другая» сторона операции. Для большинства операций это будет один скаляр.
**kwargs – модификаторы. Они могут передаваться специальными операторами, такими как ColumnOperators.contains().

attribute sqlalchemy.orm.PropComparator.property¶

Возвращает MapperProperty, связанный с данным PropComparator.

Возвращаемые значения здесь обычно являются экземплярами ColumnProperty или Relationship.

method sqlalchemy.orm.PropComparator.regexp_match(pattern: Any, flags: Optional[str] = None) → ColumnOperators¶

наследуется от ColumnOperators.regexp_match() метода ColumnOperators

Реализует специфический для базы данных оператор „regexp match“.

Например:

stmt = select(table.c.some_column).where(
    table.c.some_column.regexp_match('^(b|c)')
)

ColumnOperators.regexp_match() пытается преобразоваться в REGEXP-подобную функцию или оператор, предоставляемый бэкендом, однако конкретный синтаксис регулярного выражения и доступные флаги не зависят от бэкенда.

Примеры включают:

PostgreSQL - выдает x ~ y или x !~ y при отрицании.
Oracle - выдает REGEXP_LIKE(x, y).
SQLite - использует оператор-заместитель SQLite REGEXP и обращается к встроенной программе Python re.match().
другие бэкенды могут предоставлять специальные реализации.
Бэкенды без специальной реализации будут выдавать оператор как «REGEXP» или «NOT REGEXP». Это совместимо, например, с SQLite и MySQL.

В настоящее время поддержка регулярных выражений реализована для Oracle, PostgreSQL, MySQL и MariaDB. Частичная поддержка доступна для SQLite. Поддержка сторонних диалектов может отличаться.

Параметры:

pattern – Строка шаблона регулярного выражения или предложение столбца.
flags – Любые флаги строк регулярных выражений для применения. Флаги, как правило, зависят от бэкенда. Это может быть строка или предложение столбца. Некоторые бэкенды, например PostgreSQL и MariaDB, могут альтернативно указывать флаги как часть шаблона. При использовании флага игнорирования регистра „i“ в PostgreSQL будет использован оператор соответствия регэкспа ~* или !~*.

Добавлено в версии 1.4.

См.также

ColumnOperators.regexp_replace()

method sqlalchemy.orm.PropComparator.regexp_replace(pattern: Any, replacement: Any, flags: Optional[str] = None) → ColumnOperators¶

наследуется от ColumnOperators.regexp_replace() метода ColumnOperators

Реализует специфический для базы данных оператор „regexp replace“.

Например:

stmt = select(
    table.c.some_column.regexp_replace(
        'b(..)',
        'XY',
        flags='g'
    )
)

ColumnOperators.regexp_replace() пытается разрешиться в REGEXP_REPLACE-подобную функцию, предоставляемую бэкендом, который обычно выдает функцию REGEXP_REPLACE(). Однако конкретный синтаксис регулярного выражения и доступные флаги не зависят от бэкенда.

Поддержка замены регулярных выражений в настоящее время реализована для Oracle, PostgreSQL, MySQL 8 или выше и MariaDB. Поддержка сторонних диалектов может отличаться.

Параметры:

pattern – Строка шаблона регулярного выражения или предложение столбца.
pattern – Заменяющая строка или предложение столбца.
flags – Любые флаги строк регулярных выражений для применения. Флаги, как правило, зависят от бэкенда. Это может быть строка или предложение столбца. Некоторые бэкенды, например PostgreSQL и MariaDB, могут альтернативно указывать флаги как часть шаблона.

Добавлено в версии 1.4.

См.также

ColumnOperators.regexp_match()

method sqlalchemy.orm.PropComparator.reverse_operate(op: OperatorType, other: Any, **kwargs: Any) → Operators¶

наследуется от Operators.reverse_operate() метода Operators

Обратное действие над аргументом.

Используется так же, как и operate().

method sqlalchemy.orm.PropComparator.startswith(other: Any, escape: Optional[str] = None, autoescape: bool = False) → ColumnOperators¶

наследуется от ColumnOperators.startswith() метода ColumnOperators

Реализуйте оператор startswith.

Выдает выражение LIKE, которое проверяет совпадение с началом строкового значения:

column LIKE <other> || '%'

Например:

stmt = select(sometable).\
    where(sometable.c.column.startswith("foobar"))

Поскольку оператор использует LIKE, символы подстановки "%" и "_", присутствующие внутри выражения <other>, также будут вести себя как символы подстановки. Для буквальных строковых значений флаг ColumnOperators.startswith.autoescape может быть установлен в значение True, чтобы применить экранирование к вхождениям этих символов в строковое значение так, чтобы они совпадали сами по себе, а не как символы подстановки. В качестве альтернативы, параметр ColumnOperators.startswith.escape устанавливает данный символ как символ экранирования, что может быть полезно, когда целевое выражение не является литеральной строкой.

Параметры:

other – выражение для сравнения. Обычно это обычное строковое значение, но может быть и произвольным выражением SQL. Символы подстановки LIKE % и _ по умолчанию не экранируются, если только флаг ColumnOperators.startswith.autoescape не установлен в True.
autoescape – boolean; при True устанавливает символ экранирования в выражении LIKE, затем применяет его ко всем вхождениям "%", "_" и самого символа экранирования в значении сравнения, которое считается литеральной строкой, а не выражением SQL. Выражение типа:: somecolumn.startswith(«foo%bar», autoescape=True) будет выглядеть так:: somecolumn LIKE :param || „%“ ESCAPE „/“ Со значением :param как "foo/%bar".
escape – символ, который при передаче будет отображаться с ключевым словом ESCAPE, чтобы установить этот символ в качестве управляющего символа. Затем этот символ может быть помещен перед вхождениями % и _, чтобы позволить им действовать как самим себе, а не как символам подстановки. Выражение типа:: somecolumn.startswith(«foo/%bar», escape=»^») будет выглядеть так:: somecolumn LIKE :param || „%“ ESCAPE „^“ Параметр также может быть объединен с ColumnOperators.startswith.autoescape:: somecolumn.startswith(«foo%bar^bat», escape=»^», autoescape=True) Где выше, данный литеральный параметр будет преобразован в "foo^%bar^^bat" перед передачей в базу данных.

См.также

ColumnOperators.endswith()

ColumnOperators.contains()

attribute sqlalchemy.orm.PropComparator.timetuple: Literal[None] = None¶: наследуется от ColumnOperators.timetuple атрибута ColumnOperators

Hack, позволяет сравнивать объекты времени даты на LHS.

class sqlalchemy.orm.Relationship¶

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

Публичный конструктор - это функция relationship().

См.также

Конфигурация отношений

Изменено в версии 2.0: Добавлен Relationship в качестве подкласса, совместимого с декларативным методом, для RelationshipProperty.

Классная подпись

class sqlalchemy.orm.Relationship (sqlalchemy.orm.RelationshipProperty, sqlalchemy.orm.base._DeclarativeMapped, sqlalchemy.orm.base.WriteOnlyMapped, sqlalchemy.orm.base.DynamicMapped)

class sqlalchemy.orm.RelationshipDirection¶

перечисление, которое указывает «направление» RelationshipProperty.

RelationshipDirection доступен из атрибута Relationship.direction в RelationshipProperty.

Members

MANYTOMANY, MANYTOONE, ONETOMANY

Классная подпись

класс sqlalchemy.orm.RelationshipDirection (enum.Enum)

attribute sqlalchemy.orm.RelationshipDirection.MANYTOMANY = 3¶

Указывает направление «многие-ко-многим» для relationship().

Этот символ обычно используется внутренними модулями, но может быть раскрыт в некоторых функциях API.

attribute sqlalchemy.orm.RelationshipDirection.MANYTOONE = 2¶

Указывает направление «многие-к-одному» для relationship().

Этот символ обычно используется внутренними модулями, но может быть раскрыт в некоторых функциях API.

attribute sqlalchemy.orm.RelationshipDirection.ONETOMANY = 1¶

Указывает направление «один-ко-многим» для relationship().

Этот символ обычно используется внутренними модулями, но может быть раскрыт в некоторых функциях API.

class sqlalchemy.orm.RelationshipProperty¶

Публичный конструктор - это функция relationship().

См.также

Конфигурация отношений

Members

__eq__(), __init__(), __ne__(), adapt_to_entity(), and_(), any(), contains(), entity, has(), in_(), mapper, of_type(), cascade, cascade_iterator(), declarative_scan(), do_init(), entity, instrument_class(), mapper, merge()

Классная подпись

class sqlalchemy.orm.RelationshipProperty (sqlalchemy.orm._IntrospectsAnnotations, sqlalchemy.orm.StrategizedProperty, sqlalchemy.log.Identified)

class Comparator¶

Производить булевы, сравнительные и другие операторы для атрибутов RelationshipProperty.

См. документацию для PropComparator для краткого обзора определения оператора уровня ORM.

См.также

PropComparator

Comparator

QueryableAttribute.info

Классная подпись

класс sqlalchemy.orm.RelationshipProperty.Comparator (sqlalchemy.util.langhelpers.MemoizedSlots, sqlalchemy.orm.PropComparator)

method sqlalchemy.orm.RelationshipProperty.Comparator.__eq__(other: Any) → ColumnElement[bool]¶

Реализуйте оператор ==.

В контексте «многие к одному», например:

MyClass.some_prop == <some object>

обычно получается предложение типа:

mytable.related_id == <some id>

Где <some id> - первичный ключ данного объекта.

Оператор == обеспечивает частичную функциональность для сравнений не «многие-к-одному»:

Сравнение с коллекциями не поддерживается. Используйте Comparator.contains().
По сравнению со скалярным one-to-many выдает предложение, которое сравнивает целевые столбцы родителя с заданной целью.
По сравнению со скалярным many-to-many, псевдоним таблицы ассоциации также будет отображен, формируя естественное соединение, которое является частью основного тела запроса. Это не будет работать для запросов, которые выходят за рамки простой конъюнкции сравнений AND, например, тех, которые используют OR. Используйте явные соединения, внешние соединения или Comparator.has() для более полных скалярных тестов на принадлежность не «многие к одному».
Сравнение с None, заданное в контексте «один ко многим» или «многие ко многим», дает предложение NOT EXISTS.

method sqlalchemy.orm.RelationshipProperty.Comparator.__init__(prop: RelationshipProperty[_PT], parentmapper: _InternalEntityType[Any], adapt_to_entity: Optional[AliasedInsp[Any]] = None, of_type: Optional[_EntityType[_PT]] = None, extra_criteria: Tuple[ColumnElement[bool], ...] = ())¶: Построение Comparator является внутренним для механики атрибутов ORM.

method sqlalchemy.orm.RelationshipProperty.Comparator.__ne__(other: Any) → ColumnElement[bool]¶

Реализуйте оператор !=.

В контексте «многие к одному», например:

MyClass.some_prop != <some object>

Обычно это приводит к появлению такого пункта, как:

mytable.related_id != <some id>

Где <some id> - первичный ключ данного объекта.

Оператор != обеспечивает частичную функциональность для сравнений не «многие-к-одному»:

Сравнение с коллекциями не поддерживается. Используйте Comparator.contains() в сочетании с not_().
По сравнению со скалярным one-to-many выдает предложение, которое сравнивает целевые столбцы родителя с заданной целью.
По сравнению со скалярным many-to-many, псевдоним таблицы ассоциации также будет отображен, формируя естественное соединение, которое является частью основного тела запроса. Это не будет работать для запросов, которые выходят за рамки простой конъюнкции сравнений AND, например, тех, которые используют OR. Используйте явные соединения, внешние соединения или Comparator.has() в сочетании с not_() для более полных скалярных тестов членства не «от человека к человеку».
Сравнение с None, заданное в контексте «один ко многим» или «многие ко многим», дает предложение EXISTS.

method sqlalchemy.orm.RelationshipProperty.Comparator.adapt_to_entity(adapt_to_entity: AliasedInsp[Any]) → RelationshipProperty.Comparator[Any]¶: Возвращает копию этого PropComparator, который будет использовать заданные AliasedInsp для получения соответствующих выражений.

method sqlalchemy.orm.RelationshipProperty.Comparator.and_(*criteria: _ColumnExpressionArgument[bool]) → PropComparator[Any]¶

Добавьте критерии AND.

Смотрите пример PropComparator.and_().

Добавлено в версии 1.4.

method sqlalchemy.orm.RelationshipProperty.Comparator.any(criterion: Optional[_ColumnExpressionArgument[bool]] = None, **kwargs: Any) → ColumnElement[bool]¶

Создайте выражение, которое проверяет коллекцию по определенному критерию, используя EXISTS.

Выражение типа:

session.query(MyClass).filter(
    MyClass.somereference.any(SomeRelated.x==2)
)

Получится запрос вида:

SELECT * FROM my_table WHERE
EXISTS (SELECT 1 FROM related WHERE related.my_id=my_table.id
AND related.x=2)

Поскольку Comparator.any() использует коррелированный подзапрос, его производительность при сравнении с большими целевыми таблицами не так высока, как при использовании объединения.

Comparator.any() особенно полезно для проверки пустых коллекций:

session.query(MyClass).filter(
    ~MyClass.somereference.any()
)

будет производить:

SELECT * FROM my_table WHERE
NOT (EXISTS (SELECT 1 FROM related WHERE
related.my_id=my_table.id))

Comparator.any() действителен только для коллекций, т.е. relationship(), который имеет uselist=True. Для скалярных ссылок используйте Comparator.has().

method sqlalchemy.orm.RelationshipProperty.Comparator.contains(other: _ColumnExpressionArgument[Any], **kwargs: Any) → ColumnElement[bool]¶

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

Comparator.contains() действует только для коллекции, т.е. relationship(), которая реализуется по принципу «один ко многим» или «многие ко многим» с помощью uselist=True.

При использовании в простом контексте «один ко многим» выражение типа:

MyClass.contains(other)

Производит предложение типа:

mytable.id == <some id>

Где <some id> - это значение атрибута внешнего ключа на other, который ссылается на первичный ключ родительского объекта. Из этого следует, что Comparator.contains() очень полезен при использовании с простыми операциями «один-ко-многим».

Для операций «многие ко многим» поведение Comparator.contains() имеет больше оговорок. Таблица объединения будет отображаться в операторе, создавая «неявное» объединение, то есть включает несколько таблиц в предложение FROM, которые приравниваются в предложении WHERE:

query(MyClass).filter(MyClass.contains(other))

Выдает запрос вида:

SELECT * FROM my_table, my_association_table AS
my_association_table_1 WHERE
my_table.id = my_association_table_1.parent_id
AND my_association_table_1.child_id = <some id>

Где <some id> будет первичным ключом other. Из вышесказанного ясно, что Comparator.contains() не будет работать с коллекциями «многие-ко-многим» при использовании в запросах, выходящих за рамки простых конъюнкций AND, таких как несколько выражений Comparator.contains(), объединенных OR. В таких случаях необходимо использовать подзапросы или явные «внешние соединения». Смотрите Comparator.any() для менее производительной альтернативы с использованием EXISTS, или обратитесь к Query.outerjoin(), а также Присоединяйтесь к для более подробной информации о построении внешних объединений.

kwargs могут игнорироваться этим оператором, но необходимы для соответствия API.

attribute sqlalchemy.orm.RelationshipProperty.Comparator.entity: _InternalEntityType[_PT]¶

Целевая сущность, на которую ссылается данный Comparator.

Это либо объект Mapper, либо AliasedInsp.

Это «целевая» или «удаленная» сторона relationship().

method sqlalchemy.orm.RelationshipProperty.Comparator.has(criterion: Optional[_ColumnExpressionArgument[bool]] = None, **kwargs: Any) → ColumnElement[bool]¶

Создайте выражение, которое проверяет скалярную ссылку на соответствие определенному критерию, используя EXISTS.

Выражение типа:

session.query(MyClass).filter(
    MyClass.somereference.has(SomeRelated.x==2)
)

Получится запрос вида:

SELECT * FROM my_table WHERE
EXISTS (SELECT 1 FROM related WHERE
related.id==my_table.related_id AND related.x=2)

Поскольку Comparator.has() использует коррелированный подзапрос, его производительность при сравнении с большими целевыми таблицами не так высока, как при использовании объединения.

Comparator.has() действует только для скалярных ссылок, т.е. relationship(), который имеет uselist=False. Для ссылок на коллекции используйте Comparator.any().

method sqlalchemy.orm.RelationshipProperty.Comparator.in_(other: Any) → NoReturn¶: Производить предложение IN - на данный момент это не реализовано для атрибутов на основе relationship().

attribute sqlalchemy.orm.RelationshipProperty.Comparator.mapper: Mapper[_PT]¶

Цель Mapper, на которую ссылается данный Comparator.

Это «целевая» или «удаленная» сторона relationship().

method sqlalchemy.orm.RelationshipProperty.Comparator.of_type(class_: _EntityType[Any]) → PropComparator[_PT]¶

Переопределите этот объект в терминах полиморфного подкласса.

Смотрите пример PropComparator.of_type().

attribute sqlalchemy.orm.RelationshipProperty.cascade¶: Возвращает текущую настройку каскада для данного RelationshipProperty.

method sqlalchemy.orm.RelationshipProperty.cascade_iterator(type_: str, state: InstanceState[Any], dict_: _InstanceDict, visited_states: Set[InstanceState[Any]], halt_on: Optional[Callable[[InstanceState[Any]], bool]] = None) → Iterator[Tuple[Any, Mapper[Any], InstanceState[Any], _InstanceDict]]¶

Возвращает итератор3-кортежей (экземпляр, картограф, состояние).

Этот метод обычно применяется только к Отношениям.

method sqlalchemy.orm.RelationshipProperty.declarative_scan(decl_scan: _ClassScanMapperConfig, registry: _RegistryType, cls: Type[Any], originating_module: Optional[str], key: str, mapped_container: Optional[Type[Mapped[Any]]], annotation: Optional[_AnnotationScanType], extracted_mapped_annotation: Optional[_AnnotationScanType], is_dataclass_field: bool) → None¶: Выполняйте специфическую для класса инициализацию на ранних стадиях декларативного сканирования.

Добавлено в версии 2.0.

method sqlalchemy.orm.RelationshipProperty.do_init() → None¶

Выполните шаги инициализации, специфичные для подклассов, после создания картографа.

Это шаблонный метод, вызываемый методом init() объекта MapperProperty.

attribute sqlalchemy.orm.RelationshipProperty.entity¶: Возвращает целевую сопоставленную сущность, которая является inspect() класса или псевдокласса, на который ссылается.

method sqlalchemy.orm.RelationshipProperty.instrument_class(mapper: Mapper[Any]) → None¶

Здесь MapperProperty обычно обращается к модулю атрибутов для установки InstrumentedAttribute.

attribute sqlalchemy.orm.RelationshipProperty.mapper¶: Возвращает целевой Mapper для данного RelationshipProperty.

method sqlalchemy.orm.RelationshipProperty.merge(session: Session, source_state: InstanceState[Any], source_dict: _InstanceDict, dest_state: InstanceState[Any], dest_dict: _InstanceDict, load: bool, _recursive: Dict[Any, object], _resolve_conflict_map: Dict[_IdentityKeyType[Any], object]) → None¶: Объединить атрибут, представленный этим MapperProperty, с объектом-источником и объектом-получателем.

class sqlalchemy.orm.SQLORMExpression¶

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

SQLORMExpression расширяет ядро SQLColumnExpression для добавления дополнительных методов SQL, специфичных для ORM, таких как PropComparator.of_type(), и является частью основ для InstrumentedAttribute. Он может использоваться в типизации PEP 484 для указания аргументов или возвращаемых значений, которые должны вести себя как выражения атрибутов на уровне ORM.

Добавлено в версии 2.0.0b4.

Классная подпись

class sqlalchemy.orm.SQLORMExpression (sqlalchemy.orm.base.SQLORMOperations, sqlalchemy.sql.expression.SQLColumnExpression, sqlalchemy.util.langhelpers.TypingOnly)

class sqlalchemy.orm.Synonym¶

Декларативный внешний интерфейс для класса SynonymProperty.

Публичный конструктор - это функция synonym().

Изменено в версии 2.0: Добавлено Synonym в качестве подкласса, совместимого с декларативным методом, для SynonymProperty

См.также

Синонимы - Обзор синонимов

Классная подпись

класс sqlalchemy.orm.Synonym (sqlalchemy.orm.descriptor_props.SynonymProperty, sqlalchemy.orm.base._DeclarativeMapped)

class sqlalchemy.orm.SynonymProperty¶

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

Synonym строится с помощью функции synonym().

См.также

Синонимы - Обзор синонимов

Members

doc, info, key, parent, set_parent(), uses_objects

Классная подпись

класс sqlalchemy.orm.SynonymProperty (sqlalchemy.orm.descriptor_props.DescriptorProperty)

attribute sqlalchemy.orm.SynonymProperty.doc: Optional[str]¶: наследуется от DescriptorProperty.doc атрибута DescriptorProperty

необязательная строка документации

attribute sqlalchemy.orm.SynonymProperty.info: _InfoType¶

наследуется от MapperProperty.info атрибута MapperProperty

Информационный словарь, связанный с объектом, позволяющий связать пользовательские данные с этим InspectionAttr.

См.также

Mapper.all_orm_descriptors

attribute sqlalchemy.orm.SynonymProperty.key: str¶: наследуется от MapperProperty.key атрибута MapperProperty

имя атрибута класса

attribute sqlalchemy.orm.SynonymProperty.parent: Mapper[Any]¶: наследуется от MapperProperty.parent атрибута MapperProperty

Mapper, управляющий этим свойством.

method sqlalchemy.orm.SynonymProperty.set_parent(parent: Mapper[Any], init: bool) → None¶

Установите родительский маппер, который ссылается на этот MapperProperty.

attribute sqlalchemy.orm.SynonymProperty.uses_objects¶

class sqlalchemy.orm.QueryContext¶

class default_load_options¶: Классная подпись

класс sqlalchemy.orm.QueryContext.default_load_options (sqlalchemy.sql.expression.Options)

class sqlalchemy.orm.QueryableAttribute¶

Базовый класс для объектов descriptor, которые перехватывают события атрибутов от имени объекта MapperProperty. Собственно MapperProperty доступен через атрибут QueryableAttribute.property.

См.также

InstrumentedAttribute

MapperProperty

Mapper.attrs

Members

adapt_to_entity(), and_(), expression, info, is_attribute, of_type(), operate(), parent, reverse_operate()

Классная подпись

class sqlalchemy.orm.QueryableAttribute (sqlalchemy.orm.base._DeclarativeMapped, sqlalchemy.orm.base.SQLORMExpression, sqlalchemy.orm.base.InspectionAttr, sqlalchemy.orm.PropComparator, sqlalchemy.sql.roles.JoinTargetRole, sqlalchemy.sql.roles.OnClauseRole, sqlalchemy.sql.expression.Immutable, sqlalchemy.sql.cache_key.SlotsMemoizedHasCacheKey, sqlalchemy.util.langhelpers.MemoizedSlots, sqlalchemy.event.registry.EventTarget)

method sqlalchemy.orm.QueryableAttribute.adapt_to_entity(adapt_to_entity: AliasedInsp[Any]) → Self¶: Возвращает копию этого PropComparator, который будет использовать заданные AliasedInsp для получения соответствующих выражений.

method sqlalchemy.orm.QueryableAttribute.and_(*clauses: _ColumnExpressionArgument[bool]) → QueryableAttribute[bool]¶

Добавьте дополнительные критерии к предложению ON, которое представлено этим атрибутом отношения.

Например:

stmt = select(User).join(
    User.addresses.and_(Address.email_address != 'foo')
)

stmt = select(User).options(
    joinedload(User.addresses.and_(Address.email_address != 'foo'))
)

Добавлено в версии 1.4.

См.также

Объединение отношений с пользовательскими критериями ON

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

with_loader_criteria()

attribute sqlalchemy.orm.QueryableAttribute.expression: ColumnElement[_T]¶

Объект выражения SQL, представленный данным QueryableAttribute.

Обычно это экземпляр подкласса ColumnElement, представляющий выражение столбца.

attribute sqlalchemy.orm.QueryableAttribute.info¶

Возвращает словарь „info“ для базового элемента SQL.

Поведение здесь следующее:

Если атрибут является свойством, отображенным на столбец, т.е. ColumnProperty, которое отображено непосредственно на объект уровня схемы Column, то этот атрибут вернет словарь SchemaItem.info, связанный с объектом уровня ядра Column.
Если атрибут является ColumnProperty, но сопоставлен с любым другим видом SQL выражения, отличным от Column, атрибут будет ссылаться на словарь MapperProperty.info, связанный непосредственно с ColumnProperty, при условии, что само SQL выражение не имеет собственного атрибута .info (так и должно быть, если только пользовательская SQL конструкция не определила его).
Если атрибут ссылается на любой другой вид MapperProperty, включая Relationship, атрибут будет ссылаться на словарь MapperProperty.info, связанный с этим MapperProperty.
Для безусловного доступа к словарю MapperProperty.info словаря MapperProperty, в том числе для ColumnProperty, связанного непосредственно с Column, на атрибут можно ссылаться с помощью атрибута QueryableAttribute.property, как MyClass.someattribute.property.info.

См.также