SQLAlchemy 2.0 Dokumentation

Zusammensetzung aus Spalteneigenschaften zur Zuordnungszeit

Klassensignatur

class sqlalchemy.orm.ColumnProperty.Comparator (sqlalchemy.util.langhelpers.MemoizedSlots, sqlalchemy.orm.PropComparator)

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

Die vollständige Sequenz der Spalten, auf die dieses: Attribut verweist, angepasst an die gerade stattfindende Aliasbildung.

Neu in Version 1.3.17.

Siehe auch

Mapping einer Klasse gegen mehrere Tabellen - Anwendungsbeispiel

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

Operiert auf einem Argument.

Dies ist die niedrigste Ebene der Operation, löst standardmäßig NotImplementedError aus.

Das Überschreiben dieser Methode in einer Unterklasse kann dazu dienen, ein gemeinsames Verhalten auf alle Operationen anzuwenden. Zum Beispiel kann das Überschreiben von ColumnOperators dazu dienen, func.lower() auf die linke und rechte Seite anzuwenden.

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

Parameter:

op¶ – Operator-Callable.
*other¶ – die „andere“ Seite der Operation. Wird bei den meisten Operationen ein einzelner Skalar sein.
**kwargs¶ – Modifikatoren. Diese können von speziellen Operatoren wie ColumnOperators.contains() übergeben werden.

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

Umgekehrte Operation auf ein Argument.

Die Verwendung ist dieselbe wie bei operate().

attribute sqlalchemy.orm.ColumnProperty.columns_to_assign¶

method sqlalchemy.orm.ColumnProperty.declarative_scan(decl_scan: _ClassScanMapperConfig, registry: _RegistryType, cls: Type[Any], originating_module: str | None, key: str, mapped_container: Type[Mapped[Any]] | None, annotation: _AnnotationScanType | None, extracted_mapped_annotation: _AnnotationScanType | None, is_dataclass_field: bool) → None¶: Führt eine klassenspezifische Initialisierung zum frühen Zeitpunkt des deklarativen Scannens durch.

Neu in Version 2.0.

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

Führt subklassenspezifische Initialisierungsschritte nach der Mapper-Erstellung durch.

Dies ist eine Vorlagenmethode, die von der init()-Methode des MapperProperty-Objekts aufgerufen wird.

attribute sqlalchemy.orm.ColumnProperty.expression¶

Gibt die primäre Spalte oder den primären Ausdruck für diese ColumnProperty zurück.

Z. B.

class File(Base):
    # ...

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

Siehe auch

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

Hook, der vom Mapper aufgerufen wird, um die Instrumentierung des Klassenattributs, das von dieser MapperProperty verwaltet wird, zu initiieren.

Die MapperProperty ruft hier typischerweise das attributes-Modul auf, um ein InstrumentedAttribute einzurichten.

Dieser Schritt ist der erste von zwei Schritten zur Einrichtung eines InstrumentedAttribute und wird früh im Mapper-Einrichtungsprozess aufgerufen.

Der zweite Schritt ist typischerweise der Schritt init_class_attribute, der von StrategizedProperty über den post_instrument_class()-Hook aufgerufen wird. Dieser Schritt weist dem InstrumentedAttribute (insbesondere der "impl") zusätzlichen Zustand zu, der ermittelt wurde, nachdem die MapperProperty bestimmt hat, welche Art von Persistenzverwaltung sie durchführen muss (z. B. Skalar, Objekt, Sammlung usw.).

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¶: Führt das von dieser MapperProperty dargestellte Attribut von der Quelle zum Zielobjekt zusammen.

class sqlalchemy.orm.Composite¶

Deklarationskompatibles Frontend für die Klasse CompositeProperty.

Der öffentliche Konstruktor ist die Funktion composite().

Geändert in Version 2.0: Composite als deklarativ-kompatible Unterklasse von CompositeProperty hinzugefügt.

Siehe auch

Zusammengesetzte Spaltentypen

Klassensignatur

class sqlalchemy.orm.Composite (sqlalchemy.orm.descriptor_props.CompositeProperty, sqlalchemy.orm.base._DeclarativeMapped)

class sqlalchemy.orm.CompositeProperty¶

Definiert ein „zusammengesetztes“ zugeordnetes Attribut, das eine Sammlung von Spalten als ein Attribut darstellt.

CompositeProperty wird mit der Funktion composite() konstruiert.

Siehe auch

Zusammengesetzte Spaltentypen

Mitglieder

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

Klassensignatur

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

class Comparator¶

Erzeugt boolesche, Vergleichs- und andere Operatoren für Composite-Attribute.

Siehe das Beispiel in Neudefinition von Vergleichsoperationen für Composites für einen Überblick über die Verwendung sowie die Dokumentation für PropComparator.

Siehe auch

PropComparator

Mapper.all_orm_descriptors

Klassensignatur

class sqlalchemy.orm.CompositeProperty.Comparator (sqlalchemy.orm.PropComparator)

class CompositeBundle¶

Klassensignatur

class 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]¶

Erzeugt die Funktion "Zeilenverarbeitung" für dieses Bundle.

Kann von Unterklassen überschrieben werden, um benutzerdefiniertes Verhalten bei Abrufergebnissen bereitzustellen. Die Methode erhält zur Abfrageausführungszeit das Statement-Objekt und eine Menge von "Zeilenverarbeitungs"-Funktionen; diese Verarbeitungsfunktionen geben beim Empfang einer Ergebniszeile den einzelnen Attributwert zurück, der dann in jede beliebige Datenstruktur adaptiert werden kann.

Das folgende Beispiel veranschaulicht das Ersetzen der üblichen Row-Rückgabestruktur durch ein direktes Python-Dictionary

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

Ein Ergebnis des obigen Bundle gibt Wörterbuchwerte zurück

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: str | None, key: str, mapped_container: Type[Mapped[Any]] | None, annotation: _AnnotationScanType | None, extracted_mapped_annotation: _AnnotationScanType | None, is_dataclass_field: bool) → None¶: Führt eine klassenspezifische Initialisierung zum frühen Zeitpunkt des deklarativen Scannens durch.

Neu in Version 2.0.

method sqlalchemy.orm.CompositeProperty.do_init() → None¶: Initialisierung, die erfolgt, nachdem der Composite seinem übergeordneten Mapper zugeordnet wurde.

method sqlalchemy.orm.CompositeProperty.get_history(state: InstanceState[Any], dict_: _InstanceDict, passive: PassiveFlag = symbol('PASSIVE_OFF')) → History¶: Bereitgestellt für benutzerdefinierten Code, der attributes.get_history() verwendet.

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

Hook, der vom Mapper aufgerufen wird, um die Instrumentierung des Klassenattributs, das von dieser MapperProperty verwaltet wird, zu initiieren.

Die MapperProperty ruft hier typischerweise das attributes-Modul auf, um ein InstrumentedAttribute einzurichten.

Dieser Schritt ist der erste von zwei Schritten zur Einrichtung eines InstrumentedAttribute und wird früh im Mapper-Einrichtungsprozess aufgerufen.

Der zweite Schritt ist typischerweise der Schritt init_class_attribute, der von StrategizedProperty über den post_instrument_class()-Hook aufgerufen wird. Dieser Schritt weist dem InstrumentedAttribute (insbesondere der "impl") zusätzlichen Zustand zu, der ermittelt wurde, nachdem die MapperProperty bestimmt hat, welche Art von Persistenzverwaltung sie durchführen muss (z. B. Skalar, Objekt, Sammlung usw.).

attribute sqlalchemy.orm.CompositeProperty.mapper_property_to_assign¶

class sqlalchemy.orm.AttributeEventToken¶

Ein Token, das während einer Kette von Attribut-Ereignissen weitergegeben wird.

Dient als Indikator für die Quelle des Ereignisses und bietet auch eine Möglichkeit, die Ausbreitung über eine Kette von Attributoperationen zu steuern.

Das Event-Objekt wird als initiator-Argument übergeben, wenn Ereignisse wie AttributeEvents.append(), AttributeEvents.set() und AttributeEvents.remove() behandelt werden.

Das Event-Objekt wird derzeit von den Backref-Ereignisbehandlern interpretiert und zur Steuerung der Ausbreitung von Operationen über zwei gegenseitig abhängige Attribute verwendet.

Geändert in Version 2.0: Der Name wurde von AttributeEvent in AttributeEventToken geändert.

Attribut-Impl::: Das AttributeImpl, das der aktuelle Ereignisinitiator ist.
Attribut-Op::: Das Symbol OP_APPEND, OP_REMOVE, OP_REPLACE oder OP_BULK_REPLACE, das die Quelle der Operation angibt.

class sqlalchemy.orm.IdentityMap¶

Mitglieder

check_modified()

method sqlalchemy.orm.IdentityMap.check_modified() → bool¶: Gibt True zurück, wenn irgendeine Instanz von InstanceStates als 'modifiziert' markiert wurde.

class sqlalchemy.orm.InspectionAttr¶

Eine Basisklasse, die auf alle ORM-Objekte und Attribute angewendet wird, die sich auf Dinge beziehen, die von der Funktion inspect() zurückgegeben werden können.

Die hier definierten Attribute ermöglichen die Verwendung einfacher boolescher Prüfungen, um grundlegende Fakten über das zurückgegebene Objekt zu testen.

Mitglieder

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

Während die booleschen Prüfungen hier im Grunde die gleichen sind wie die Verwendung der Python isinstance()-Funktion, können die Flags hier verwendet werden, ohne dass alle diese Klassen importiert werden müssen, und auch so, dass das SQLAlchemy-Klassensystem geändert werden kann, während die Flags hier für die zukünftige Kompatibilität beibehalten werden.

attribute sqlalchemy.orm.InspectionAttr.extension_type: InspectionAttrExtensionType = 'not_extension'¶: Der Erweiterungstyp, falls vorhanden. Standard ist NotExtension.NOT_EXTENSION

Siehe auch

HybridExtensionType

AssociationProxyExtensionType

attribute sqlalchemy.orm.InspectionAttr.is_aliased_class = False¶: True, wenn dieses Objekt eine Instanz von AliasedClass ist.

attribute sqlalchemy.orm.InspectionAttr.is_attribute = False¶

True, wenn dieses Objekt ein Python Deskriptor ist.

Dies kann sich auf verschiedene Typen beziehen. Normalerweise ein QueryableAttribute, das Attributereignisse im Auftrag einer MapperProperty behandelt. Kann aber auch ein Erweiterungstyp wie AssociationProxy oder hybrid_property sein. Die InspectionAttr.extension_type verweist auf eine Konstante, die den spezifischen Untertyp identifiziert.

Siehe auch

attribute sqlalchemy.orm.InspectionAttr.is_bundle = False¶: True, wenn dieses Objekt eine Instanz von Bundle ist.

attribute sqlalchemy.orm.InspectionAttr.is_clause_element = False¶: True, wenn dieses Objekt eine Instanz von ClauseElement ist.

attribute sqlalchemy.orm.InspectionAttr.is_instance = False¶: True, wenn dieses Objekt eine Instanz von InstanceState ist.

attribute sqlalchemy.orm.InspectionAttr.is_mapper = False¶: True, wenn dieses Objekt eine Instanz von Mapper ist.

attribute sqlalchemy.orm.InspectionAttr.is_property = False¶: True, wenn dieses Objekt eine Instanz von MapperProperty ist.

attribute sqlalchemy.orm.InspectionAttr.is_selectable = False¶: Gibt True zurück, wenn dieses Objekt eine Instanz von Selectable ist.

class sqlalchemy.orm.InspectionAttrInfo¶

Fügt das Attribut .info zu InspectionAttr hinzu.

Der Grund für InspectionAttr gegenüber InspectionAttrInfo ist, dass erstere als Mixin für Klassen kompatibel ist, die __slots__ angeben; dies ist im Wesentlichen ein Implementierungsartefakt.

Mitglieder

info

Klassensignatur

class sqlalchemy.orm.InspectionAttrInfo (sqlalchemy.orm.base.InspectionAttr)

attribute sqlalchemy.orm.InspectionAttrInfo.info¶

Info-Dictionary, das mit dem Objekt verbunden ist und es dem Benutzer ermöglicht, benutzerdefinierte Daten mit diesem InspectionAttr zu verknüpfen.

Das Dictionary wird beim ersten Zugriff generiert. Alternativ kann es als Konstruktorargument an die Funktionen column_property(), relationship() oder composite() übergeben werden.

Siehe auch

QueryableAttribute.info

Inspektion zugeordneter Instanzen

class sqlalchemy.orm.InstanceState¶

Verfolgt Zustandsinformationen auf Instanzebene.

Die InstanceState ist ein Schlüsselobjekt, das von der SQLAlchemy ORM verwendet wird, um den Zustand eines Objekts zu verfolgen; es wird in dem Moment erstellt, in dem ein Objekt instanziiert wird, typischerweise als Ergebnis der Instrumentierung, die SQLAlchemy auf die __init__() Methode der Klasse anwendet.

InstanceState ist auch ein semi-öffentliches Objekt, das zur Laufzeitinspektion des Zustands einer abgebildeten Instanz verfügbar ist, einschließlich Informationen wie ihres aktuellen Status innerhalb einer bestimmten Session und Details zu Daten einzelner Attribute. Die öffentliche API zum Erwerb eines InstanceState-Objekts ist die Verwendung des inspect()-Systems.

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

Siehe auch

Mitglieder

async_session, attrs, callables, deleted, detached, dict, expired, expired_attributes, has_identity, identity, identity_key, is_instance, mapper, modified, object, pending, persistent, session, transient, unloaded, unloaded_expirable, unmodified, unmodified_intersection(), was_deleted

Klassensignatur

class sqlalchemy.orm.InstanceState (sqlalchemy.orm.base.InspectionAttrInfo, typing.Generic)

attribute sqlalchemy.orm.InstanceState.async_session¶

Gibt die besitzende AsyncSession für diese Instanz zurück, oder None, wenn keine verfügbar ist.

Dieses Attribut ist nur dann nicht None, wenn die sqlalchemy.ext.asyncio API für dieses ORM-Objekt verwendet wird. Das zurückgegebene AsyncSession-Objekt ist ein Proxy für das Session-Objekt, das von dem InstanceState.session-Attribut für diese InstanceState zurückgegeben würde.

Neu in Version 1.4.18.

Siehe auch

Asynchrone E/A (asyncio)

attribute sqlalchemy.orm.InstanceState.attrs¶

Gibt einen Namespace zurück, der jedes Attribut des abgebildeten Objekts repräsentiert, einschließlich seines aktuellen Werts und seiner Historie.

Das zurückgegebene Objekt ist eine Instanz von AttributeState. Dieses Objekt ermöglicht die Inspektion der aktuellen Daten innerhalb eines Attributs sowie der Attributhistorie seit dem letzten Flush.

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

Ein Namespace, in dem ein pro-Status-Loader-Callable assoziiert werden kann.

In SQLAlchemy 1.0 wird dies nur für Lazy-Loader / Deferred-Loader verwendet, die über Query-Optionen eingerichtet wurden.

Zuvor wurde callables auch verwendet, um abgelaufene Attribute anzuzeigen, indem ein Link zum InstanceState selbst in diesem Dictionary gespeichert wurde. Diese Rolle wird jetzt vom Satz expired_attributes übernommen.

attribute sqlalchemy.orm.InstanceState.deleted¶

Gibt True zurück, wenn das Objekt gelöscht ist.

Ein Objekt im gelöschten Zustand ist garantiert nicht in der Session.identity_map seiner übergeordneten Session enthalten; wenn jedoch die Transaktion der Session zurückgerollt wird, wird das Objekt in den persistenten Zustand und die Identitätszuordnung zurückversetzt.

Hinweis

Das Attribut InstanceState.deleted bezieht sich auf einen bestimmten Zustand des Objekts, der zwischen dem "persistenten" und dem "detached"-Zustand auftritt; sobald das Objekt detached ist, gibt das Attribut InstanceState.deleted **nicht mehr True** zurück; um zu erkennen, dass ein Zustand gelöscht wurde, unabhängig davon, ob das Objekt mit einer Session verbunden ist oder nicht, verwenden Sie den Accessor InstanceState.was_deleted.

Siehe auch

Kurze Einführung in Objektdzustände

attribute sqlalchemy.orm.InstanceState.detached¶: Gibt True zurück, wenn das Objekt detached ist.

Siehe auch

Kurze Einführung in Objektdzustände

attribute sqlalchemy.orm.InstanceState.dict¶

Gibt das Instanz-Dict zurück, das vom Objekt verwendet wird.

Unter normalen Umständen ist dies immer gleichbedeutend mit dem __dict__-Attribut des abgebildeten Objekts, es sei denn, ein alternatives Instrumentierungssystem wurde konfiguriert.

Wenn das eigentliche Objekt vom Garbage Collector bereinigt wurde, gibt dieser Accessor ein leeres Dictionary zurück.

attribute sqlalchemy.orm.InstanceState.expired: bool = False¶: Wenn True, ist das Objekt abgelaufen.

Siehe auch

Aktualisieren / Ablaufen

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

Der Satz von Schlüsseln, die 'abgelaufen' sind, um vom verzögerten Skalar-Loader des Managers geladen zu werden, vorausgesetzt, es gibt keine ausstehenden Änderungen.

Siehe auch die Sammlung unmodified, die beim Aktualisieren mit diesem Satz geschnitten wird.

attribute sqlalchemy.orm.InstanceState.has_identity¶

Gibt True zurück, wenn dieses Objekt einen Identitätsschlüssel hat.

Dies sollte immer den gleichen Wert haben wie der Ausdruck state.persistent oder state.detached.

attribute sqlalchemy.orm.InstanceState.identity¶

Gibt die abgebildete Identität des abgebildeten Objekts zurück. Dies ist die vom ORM persistierte Primärschlüsselidentität, die immer direkt an Query.get() übergeben werden kann.

Gibt None zurück, wenn das Objekt keine Primärschlüsselidentität hat.

Hinweis

Ein Objekt, das transient oder pending ist, hat **keine** abgebildete Identität, bis es geflusht wird, selbst wenn seine Attribute Primärschlüsselwerte enthalten.

attribute sqlalchemy.orm.InstanceState.identity_key¶

Gibt den Identitätsschlüssel für das abgebildete Objekt zurück.

Dies ist der Schlüssel, der verwendet wird, um das Objekt innerhalb der Session.identity_map-Zuordnung zu lokalisieren. Er enthält die Identität, wie sie von identity zurückgegeben wird.

attribute sqlalchemy.orm.InstanceState.is_instance: bool = True¶: True, wenn dieses Objekt eine Instanz von InstanceState ist.

attribute sqlalchemy.orm.InstanceState.mapper¶: Gibt den Mapper zurück, der für dieses abgebildete Objekt verwendet wird.

attribute sqlalchemy.orm.InstanceState.modified: bool = False¶: Wenn True, wurde das Objekt geändert.

attribute sqlalchemy.orm.InstanceState.object¶

Gibt das abgebildete Objekt zurück, das von diesem InstanceState repräsentiert wird.

Gibt None zurück, wenn das Objekt vom Garbage Collector bereinigt wurde.

attribute sqlalchemy.orm.InstanceState.pending¶: Gibt True zurück, wenn das Objekt pending ist.

Siehe auch

Kurze Einführung in Objektdzustände

attribute sqlalchemy.orm.InstanceState.persistent¶

Gibt True zurück, wenn das Objekt persistent ist.

Ein Objekt im persistenten Zustand ist garantiert in der Session.identity_map seiner übergeordneten Session enthalten.

Siehe auch

Kurze Einführung in Objektdzustände

attribute sqlalchemy.orm.InstanceState.session¶

Gibt die besitzende Session für diese Instanz zurück, oder None, wenn keine verfügbar ist.

Beachten Sie, dass das Ergebnis hier in einigen Fällen von obj in session abweichen kann; ein gelöschtes Objekt meldet, dass es nicht in session ist, aber wenn die Transaktion noch läuft, verweist dieses Attribut immer noch auf diese Session. Erst wenn die Transaktion abgeschlossen ist, wird das Objekt unter normalen Umständen vollständig detached.

Siehe auch

InstanceState.async_session

attribute sqlalchemy.orm.InstanceState.transient¶: Gibt True zurück, wenn das Objekt transient ist.

Siehe auch

Kurze Einführung in Objektdzustände

attribute sqlalchemy.orm.InstanceState.unloaded¶

Gibt den Satz von Schlüsseln zurück, die keinen geladenen Wert haben.

Dies schließt abgelaufene Attribute und alle anderen Attribute ein, die nie gefüllt oder geändert wurden.

attribute sqlalchemy.orm.InstanceState.unloaded_expirable¶

Gleichbedeutend mit InstanceState.unloaded.

Veraltet seit Version 2.0: Das Attribut InstanceState.unloaded_expirable ist veraltet. Bitte verwenden Sie InstanceState.unloaded.

Dieses Attribut wurde irgendwann als implementierungsspezifisches Detail hinzugefügt und sollte als privat betrachtet werden.

attribute sqlalchemy.orm.InstanceState.unmodified¶: Gibt den Satz von Schlüsseln zurück, die keine unveränderten Änderungen aufweisen.

method sqlalchemy.orm.InstanceState.unmodified_intersection(keys: Iterable[str]) → Set[str]¶: Gibt self.unmodified.intersection(keys) zurück.

attribute sqlalchemy.orm.InstanceState.was_deleted¶

Gibt True zurück, wenn dieses Objekt im "gelöschten" Zustand ist oder war und nicht wieder persistent gemacht wurde.

Dieses Flag gibt True zurück, sobald das Objekt beim Flush gelöscht wurde. Wenn das Objekt entweder explizit oder durch einen Transaktionsabschluss aus der Session entfernt und in den "detached"-Zustand übergeht, wird dieses Flag weiterhin True melden.

Siehe auch

InstanceState.deleted - bezieht sich auf den "gelöschten" Zustand

was_deleted() - eigenständige Funktion

Kurze Einführung in Objektdzustände

class sqlalchemy.orm.InstrumentedAttribute¶: Basisklasse für Deskriptor-Objekte, die Attributereignisse im Namen eines MapperProperty-Objekts abfangen. Die tatsächliche MapperProperty ist über das Attribut QueryableAttribute.property zugänglich.

Siehe auch

InstrumentedAttribute

MapperProperty

Mapper.all_orm_descriptors

Mapper.attrs

Klassensignatur

class sqlalchemy.orm.InstrumentedAttribute (sqlalchemy.orm.QueryableAttribute)

class sqlalchemy.orm.LoaderCallableStatus¶

Eine Aufzählung.

Mitglieder

ATTR_EMPTY, ATTR_WAS_SET, NEVER_SET, NO_VALUE, PASSIVE_CLASS_MISMATCH, PASSIVE_NO_RESULT

Klassensignatur

class sqlalchemy.orm.LoaderCallableStatus (enum.Enum)

attribute sqlalchemy.orm.LoaderCallableStatus.ATTR_EMPTY = 3¶: Symbol, das intern verwendet wird, um anzuzeigen, dass ein Attribut kein Callable hatte.

attribute sqlalchemy.orm.LoaderCallableStatus.ATTR_WAS_SET = 2¶: Symbol, das von einem Loader-Callable zurückgegeben wird, um anzuzeigen, dass der abgerufene Wert oder die Werte ihren Attributen auf dem Zielobjekt zugewiesen wurden.

attribute sqlalchemy.orm.LoaderCallableStatus.NEVER_SET = 4¶: Gleichbedeutend mit NO_VALUE.

Geändert in Version 1.4: NEVER_SET wurde mit NO_VALUE zusammengeführt.

attribute sqlalchemy.orm.LoaderCallableStatus.NO_VALUE = 4¶: Symbol, das als 'vorheriger' Wert eines Attributs platziert werden kann und anzeigt, dass kein Wert für ein Attribut geladen wurde, als es geändert wurde, und Flags anzeigten, dass wir es nicht laden sollten.

attribute sqlalchemy.orm.LoaderCallableStatus.PASSIVE_CLASS_MISMATCH = 1¶: Symbol, das anzeigt, dass ein Objekt für eine bestimmte Primärschlüsselidentität lokal vorhanden ist, aber nicht von der angeforderten Klasse ist. Der Rückgabewert ist daher None und es sollte keine SQL-Abfrage gesendet werden.

attribute sqlalchemy.orm.LoaderCallableStatus.PASSIVE_NO_RESULT = 0¶: Symbol, das von einem Loader-Callable oder einer anderen Attribut-/Historienabfrageoperation zurückgegeben wird, wenn ein Wert basierend auf den Flags des Loader-Callables nicht ermittelt werden konnte.

class sqlalchemy.orm.Mapped¶

Stellt ein ORM-zugeordnetes Attribut einer zugeordneten Klasse dar.

Diese Klasse repräsentiert die vollständige Deskriptor-Schnittstelle für jedes Klassenattribut, das von der ORM Mapper-Klasse instrumentiert wurde. Bietet geeignete Informationen für Typüberprüfer wie Pylance und Mypy, damit ORM-abgebildete Attribute korrekt typisiert sind.

Die prominenteste Verwendung von Mapped erfolgt in der Deklarativen Abbildung der Mapper-Konfiguration, wo sie explizit verwendet wird, um die Konfiguration von ORM-Attributen wie mapped_class() und relationship() zu steuern.

Siehe auch

Verwendung einer deklarativen Basisklasse

Deklarative Tabelle mit mapped_column()

Tipp

Die Klasse Mapped repräsentiert Attribute, die direkt vom Mapper-Klasse behandelt werden. Sie enthält keine anderen Python-Deskriptor-Klassen, die als Erweiterungen bereitgestellt werden, einschließlich Hybrid-Attribute und des Association Proxy. Während diese Systeme weiterhin ORM-spezifische Oberklassen und Strukturen verwenden, werden sie nicht vom Mapper instrumentiert, sondern stellen ihre eigene Funktionalität bereit, wenn sie auf einer Klasse aufgerufen werden.

Neu in Version 1.4.

Klassensignatur

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

class sqlalchemy.orm.MappedColumn¶

Ordnet eine einzelne Column einer Klasse zu.

MappedColumn ist eine Spezialisierung der Klasse ColumnProperty und ist auf die deklarative Konfiguration ausgerichtet.

Um MappedColumn-Objekte zu erstellen, verwenden Sie die Konstruktorfunktion mapped_column().

Neu in Version 2.0.

Klassensignatur

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

class sqlalchemy.orm.MapperProperty¶

Stellt ein bestimmtes Klassenattribut dar, das von Mapper zugeordnet wird.

Die häufigsten Vorkommen von MapperProperty sind die zugeordneten Column, die in einer Zuordnung als Instanz von ColumnProperty dargestellt wird, und ein Verweis auf eine andere Klasse, die von relationship() erzeugt wird und in der Zuordnung als Instanz von Relationship dargestellt wird.

Mitglieder

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()

Klassensignatur

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: Callable[[InstanceState[Any]], bool] | None = None) → Iterator[Tuple[object, Mapper[Any], InstanceState[Any], _InstanceDict]]¶

Iteriert durch Instanzen, die mit der gegebenen Instanz für einen bestimmten „Cascade“ verknüpft sind, beginnend mit dieser MapperProperty.

Gibt einen Iterator von Tupeln (Instanz, Mapper, Zustand) zurück.

Beachten Sie, dass zuerst die „cascade“-Sammlung auf dieser MapperProperty für den gegebenen Typ überprüft wird, bevor cascade_iterator aufgerufen wird.

Diese Methode gilt typischerweise nur für Relationship.

attribute sqlalchemy.orm.MapperProperty.class_attribute¶

Gibt den klassengebundenen Deskriptor zurück, der dieser MapperProperty entspricht.

Dies ist im Wesentlichen ein getattr()-Aufruf

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

Wenn diese MapperProperty beispielsweise addresses genannt würde und die Klasse, der sie zugeordnet ist, User ist, ist diese Sequenz möglich

>>> 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]¶: Die PropComparator-Instanz, die SQL-Ausdruckskonstruktion im Namen dieses zugeordneten Attributs implementiert.

method sqlalchemy.orm.MapperProperty.create_row_processor(context: ORMCompileState, query_entity: _MapperEntity, path: AbstractEntityRegistry, mapper: Mapper[Any], result: Result[Any], adapter: ORMAdapter | None, populators: _PopulatorDict) → None¶: Erzeugt Zeilenverarbeitungsfunktionen und fügt sie der gegebenen Menge von Populatorenbereichen hinzu.

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

Führt subklassenspezifische Initialisierungsschritte nach der Mapper-Erstellung durch.

Dies ist eine Vorlagenmethode, die von der init()-Methode des MapperProperty-Objekts aufgerufen wird.

attribute sqlalchemy.orm.MapperProperty.doc: str | None¶: optionale Dokumentationszeichenkette

attribute sqlalchemy.orm.MapperProperty.info: _InfoType¶

Info-Dictionary, das mit dem Objekt verbunden ist und es dem Benutzer ermöglicht, benutzerdefinierte Daten mit diesem InspectionAttr zu verknüpfen.

Das Dictionary wird beim ersten Zugriff generiert. Alternativ kann es als Konstruktorargument an die Funktionen column_property(), relationship() oder composite() übergeben werden.

Siehe auch

QueryableAttribute.info

Wiederholung von Anweisungen

method sqlalchemy.orm.MapperProperty.init() → None¶: Wird nach der Erstellung aller Mapper aufgerufen, um Beziehungen zwischen Mappern zu erstellen und andere Initialisierungsschritte nach der Mapper-Erstellung durchzuführen.

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

Hook, der vom Mapper aufgerufen wird, um die Instrumentierung des Klassenattributs, das von dieser MapperProperty verwaltet wird, zu initiieren.

Die MapperProperty ruft hier typischerweise das attributes-Modul auf, um ein InstrumentedAttribute einzurichten.

Dieser Schritt ist der erste von zwei Schritten zur Einrichtung eines InstrumentedAttribute und wird früh im Mapper-Einrichtungsprozess aufgerufen.

Der zweite Schritt ist typischerweise der Schritt init_class_attribute, der von StrategizedProperty über den post_instrument_class()-Hook aufgerufen wird. Dieser Schritt weist dem InstrumentedAttribute (insbesondere der "impl") zusätzlichen Zustand zu, der ermittelt wurde, nachdem die MapperProperty bestimmt hat, welche Art von Persistenzverwaltung sie durchführen muss (z. B. Skalar, Objekt, Sammlung usw.).

attribute sqlalchemy.orm.MapperProperty.is_property = True¶: Teil der InspectionAttr-Schnittstelle; gibt an, dass dieses Objekt eine Mapper-Eigenschaft ist.

attribute sqlalchemy.orm.MapperProperty.key: str¶: Name des Klassenattributs

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¶: Führt das von dieser MapperProperty dargestellte Attribut von der Quelle zum Zielobjekt zusammen.

attribute sqlalchemy.orm.MapperProperty.parent: Mapper[Any]¶: der Mapper, der diese Eigenschaft verwaltet.

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

Führt Instrumentierungsanpassungen durch, die nach Abschluss von init() erfolgen müssen.

Der angegebene Mapper ist der Mapper, der den Vorgang aufruft, der in einem Vererbungsszenario nicht derselbe Mapper wie self.parent sein kann; Mapper ist jedoch immer zumindest ein Sub-Mapper von self.parent.

Diese Methode wird typischerweise von StrategizedProperty verwendet, die sie an LoaderStrategy.init_class_attribute() delegiert, um die endgültige Einrichtung des klassengebundenen InstrumentedAttribute durchzuführen.

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

Setzt den übergeordneten Mapper, der auf diese MapperProperty verweist.

Diese Methode wird von einigen Unterklassen überschrieben, um zusätzliche Einrichtungen durchzuführen, wenn der Mapper zum ersten Mal bekannt ist.

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

Wird von Query zum Zweck der Konstruktion einer SQL-Anweisung aufgerufen.

Jede MapperProperty, die dem Ziel-Mapper zugeordnet ist, verarbeitet die Anweisung, auf die sich der Abfragekontext bezieht, und fügt gegebenenfalls Spalten und/oder Kriterien hinzu.

class sqlalchemy.orm.MappedSQLExpression¶

Deklarationsfront-End für die Klasse ColumnProperty.

Der öffentliche Konstruktor ist die Funktion column_property().

Geändert in Version 2.0: MappedSQLExpression als deklarationskompatible Unterklasse für ColumnProperty hinzugefügt.

Siehe auch

MappedColumn

Klassensignatur

class sqlalchemy.orm.MappedSQLExpression (sqlalchemy.orm.properties.ColumnProperty, sqlalchemy.orm.base._DeclarativeMapped)

class sqlalchemy.orm.InspectionAttrExtensionType¶: Symbole, die den Typ der Erweiterung angeben, zu der ein InspectionAttr gehört.

Klassensignatur

class sqlalchemy.orm.InspectionAttrExtensionType (enum.Enum)

class sqlalchemy.orm.NotExtension¶

Eine Aufzählung.

Mitglieder

NICHT_ERWEITERUNG

Klassensignatur

class sqlalchemy.orm.NotExtension (sqlalchemy.orm.base.InspectionAttrExtensionType)

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

Symbol, das eine InspectionAttr anzeigt, die nicht Teil von sqlalchemy.ext ist.

Wird dem Attribut InspectionAttr.extension_type zugewiesen.

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

Führt ein Ergebnis in die Sitzung des angegebenen Query-Objekts zusammen.

Veraltet seit Version 2.0: Die Funktion merge_result() wird ab der 1.x-Serie von SQLAlchemy als veraltet betrachtet und wird in 2.0 zu einem veralteten Konstrukt. Die Funktion sowie die Methode auf Query wird durch die Funktion merge_frozen_result() abgelöst. (Hintergrund zu SQLAlchemy 2.0 unter: SQLAlchemy 2.0 - Hauptmigrationsanleitung)

Siehe Query.merge_result() für die Top-Level-Dokumentation dieser Funktion.

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

Führt ein FrozenResult zurück in eine Session, wobei ein neues Result-Objekt mit persistenten Objekten zurückgegeben wird.

Siehe den Abschnitt Anweisungen neu ausführen für ein Beispiel.

Siehe auch

Result.freeze()

FrozenResult

class sqlalchemy.orm.PropComparator¶

Definiert SQL-Operationen für ORM-zugeordnete Attribute.

SQLAlchemy ermöglicht die Neudefinition von Operatoren sowohl auf Core- als auch auf ORM-Ebene. PropComparator ist die Basisklasse für die Neudefinition von Operatoren für ORM-Operationen, einschließlich derer von ColumnProperty, Relationship und Composite.

Benutzerdefinierte Unterklassen von PropComparator können erstellt werden. Die integrierten Python-Vergleichs- und mathematischen Operator-Methoden, wie z. B. ColumnOperators.__eq__(), ColumnOperators.__lt__() und ColumnOperators.__add__(), können überschrieben werden, um neues Operatorverhalten bereitzustellen. Die benutzerdefinierte PropComparator wird über das Argument comparator_factory an die MapperProperty-Instanz übergeben. In jedem Fall sollte die entsprechende Unterklasse von PropComparator verwendet werden.

# 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,
    )

Beachten Sie, dass für die Neudefinition von Operatoren auf Spaltenebene es normalerweise einfacher ist, die Operatoren auf Core-Ebene zu definieren, indem das Attribut TypeEngine.comparator_factory verwendet wird. Weitere Details finden Sie unter Neudefinition und Erstellung neuer Operatoren.

Siehe auch

Comparator

Kombinieren von Beziehungen mit benutzerdefinierten ON-Kriterien

Klassensignatur

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

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

inherited from the sqlalchemy.sql.expression.ColumnOperators.__eq__ method of ColumnOperators

Implementiert den == Operator.

Im Spaltenkontext wird die Klausel a = b erzeugt. Wenn das Ziel None ist, wird a IS NULL erzeugt.

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

inherited from the sqlalchemy.sql.expression.ColumnOperators.__le__ method of ColumnOperators

Implementiert den Operator <=.

In einem Spaltenkontext wird die Klausel a <= b erzeugt.

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

inherited from the sqlalchemy.sql.expression.ColumnOperators.__lt__ method of ColumnOperators

Implementiert den Operator <.

In einem Spaltenkontext wird die Klausel a < b erzeugt.

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

inherited from the sqlalchemy.sql.expression.ColumnOperators.__ne__ method of ColumnOperators

Implementiert den Operator !=.

In einem Spaltenkontext wird die Klausel a != b erzeugt. Wenn das Ziel None ist, wird a IS NOT NULL erzeugt.

method sqlalchemy.orm.PropComparator.adapt_to_entity(adapt_to_entity: AliasedInsp[Any]) → PropComparator[_T_co]¶: Gibt eine Kopie dieses PropComparators zurück, die die angegebene AliasedInsp verwendet, um entsprechende Ausdrücke zu erzeugen.

attribute sqlalchemy.orm.PropComparator.adapter¶: Erzeugt ein aufrufbares Objekt, das Spaltenausdrücke für eine aliasierte Version dieses Comparators anpasst.

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

inherited from the ColumnOperators.all_() method of ColumnOperators

Erzeugt eine all_() Klausel gegen das übergeordnete Objekt.

Siehe die Dokumentation für all_() für Beispiele.

Hinweis

Achten Sie darauf, die neuere Methode ColumnOperators.all_() nicht mit der **veralteten** Version dieser Methode, der Methode Comparator.all(), die spezifisch für ARRAY ist und einen anderen Aufrufstil verwendet, zu verwechseln.

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

Fügt zusätzliche Kriterien zur ON-Klausel hinzu, die durch dieses Beziehungsattribut repräsentiert wird.

Z. B.

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

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

Neu in Version 1.4.

Siehe auch

Kriterien zu Loader-Optionen hinzufügen

with_loader_criteria()

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

Gibt einen SQL-Ausdruck zurück, der wahr ist, wenn dieses Element auf ein Mitglied verweist, das dem angegebenen Kriterium entspricht.

Die übliche Implementierung von any() ist Comparator.any().

Parameter:

criterion¶ – Ein optionales ClauseElement, das gegen die Tabelle oder Attribute der Mitgliedsklasse formuliert ist.
**kwargs¶ – Schlüssel-/Wertpaare, die Attributnamen der Mitgliedsklasse entsprechen und mit den entsprechenden Werten auf Gleichheit geprüft werden.

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

inherited from the ColumnOperators.any_() method of ColumnOperators

Erzeugt eine any_() Klausel gegen das übergeordnete Objekt.

Siehe die Dokumentation für any_() für Beispiele.

Hinweis

Achten Sie darauf, die neuere Methode ColumnOperators.any_() nicht mit der **veralteten** Version dieser Methode, der Methode Comparator.any(), die spezifisch für ARRAY ist und einen anderen Aufrufstil verwendet, zu verwechseln.

method sqlalchemy.orm.PropComparator.asc() → ColumnOperators¶: inherited from the ColumnOperators.asc() method of ColumnOperators

Erzeugt eine asc() Klausel gegen das übergeordnete Objekt.

method sqlalchemy.orm.PropComparator.between(cleft: Any, cright: Any, symmetric: bool = False) → ColumnOperators¶: inherited from the ColumnOperators.between() method of ColumnOperators

Erzeugt eine between() Klausel gegen das übergeordnete Objekt, gegeben den unteren und oberen Bereich.

method sqlalchemy.orm.PropComparator.bitwise_and(other: Any) → ColumnOperators¶: inherited from the ColumnOperators.bitwise_and() method of ColumnOperators

Erzeugt eine bitweise AND-Operation, typischerweise über den Operator &.

Neu in Version 2.0.2.

Siehe auch

Bitweise Operatoren

method sqlalchemy.orm.PropComparator.bitwise_lshift(other: Any) → ColumnOperators¶: inherited from the ColumnOperators.bitwise_lshift() method of ColumnOperators

Erzeugt eine bitweise LSHIFT-Operation, typischerweise über den Operator <<.

Neu in Version 2.0.2.

Siehe auch

Bitweise Operatoren

method sqlalchemy.orm.PropComparator.bitwise_not() → ColumnOperators¶: inherited from the ColumnOperators.bitwise_not() method of ColumnOperators

Erzeugt eine bitweise NOT-Operation, typischerweise über den Operator ~.

Neu in Version 2.0.2.

Siehe auch

Bitweise Operatoren

method sqlalchemy.orm.PropComparator.bitwise_or(other: Any) → ColumnOperators¶: inherited from the ColumnOperators.bitwise_or() method of ColumnOperators

Erzeugt eine bitweise OR-Operation, typischerweise über den Operator |.

Neu in Version 2.0.2.

Siehe auch

Bitweise Operatoren

method sqlalchemy.orm.PropComparator.bitwise_rshift(other: Any) → ColumnOperators¶: inherited from the ColumnOperators.bitwise_rshift() method of ColumnOperators

Erzeugt eine bitweise RSHIFT-Operation, typischerweise über den Operator >>.

Neu in Version 2.0.2.

Siehe auch

Bitweise Operatoren

method sqlalchemy.orm.PropComparator.bitwise_xor(other: Any) → ColumnOperators¶: inherited from the ColumnOperators.bitwise_xor() method of ColumnOperators

Erzeugt eine bitweise XOR-Operation, typischerweise über den Operator ^ oder # für PostgreSQL.

Neu in Version 2.0.2.

Siehe auch

Bitweise Operatoren

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

inherited from the Operators.bool_op() method of Operators

Gibt einen benutzerdefinierten booleschen Operator zurück.

Diese Methode ist eine Kurzform für den Aufruf von Operators.op() und die Übergabe des Flags Operators.op.is_comparison mit True. Ein wichtiger Vorteil der Verwendung von Operators.bool_op() besteht darin, dass bei der Verwendung von Spaltenkonstrukten die "boolesche" Natur des zurückgegebenen Ausdrucks für PEP 484-Zwecke vorhanden ist.

Siehe auch

Operators.op()

method sqlalchemy.orm.PropComparator.collate(collation: str) → ColumnOperators¶: geerbt von der ColumnOperators.collate() Methode von ColumnOperators

Erzeugt eine collate() Klausel gegen das übergeordnete Objekt, gegeben den Collation-String.

Siehe auch

collate()

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

geerbt von der ColumnOperators.concat() Methode von ColumnOperators

Implementiert den 'concat'-Operator.

In einem Spaltenkontext erzeugt dies die Klausel a || b oder verwendet den concat()-Operator unter MySQL.

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

geerbt von der ColumnOperators.contains() Methode von ColumnOperators

Implementiert den 'contains'-Operator.

Erzeugt einen LIKE-Ausdruck, der gegen eine Übereinstimmung am Ende eines String-Wertes prüft.

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

Z. B.

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

Da der Operator LIKE verwendet, verhalten sich die Wildcard-Zeichen "%" und "_", die im <other> Ausdruck vorhanden sind, ebenfalls wie Wildcards. Für literale Zeichenwerte kann das Flag ColumnOperators.contains.autoescape auf True gesetzt werden, um Escape-Zeichen auf Vorkommen dieser Zeichen innerhalb des Zeichenwerts anzuwenden, damit sie als solche und nicht als Wildcard-Zeichen übereinstimmen. Alternativ etabliert der Parameter ColumnOperators.contains.escape ein gegebenes Zeichen als Escape-Zeichen, was nützlich sein kann, wenn der Zielausdruck kein literaler Zeichenwert ist.

Parameter:

other¶ – zu vergleichender Ausdruck. Dies ist normalerweise ein einfacher Zeichenwert, kann aber auch ein beliebiger SQL-Ausdruck sein. LIKE-Wildcard-Zeichen % und _ werden standardmäßig nicht escaped, es sei denn, das Flag ColumnOperators.contains.autoescape ist auf True gesetzt.
autoescape¶ –
Boolean; wenn True, wird ein Escape-Zeichen innerhalb des LIKE-Ausdrucks etabliert und dann auf alle Vorkommen von "%", "_" und des Escape-Zeichens selbst im Vergleichswert angewendet, der als literaler String und nicht als SQL-Ausdruck angenommen wird.

Ein Ausdruck wie
```
somecolumn.contains("foo%bar", autoescape=True)
```
Wird gerendert als
```
somecolumn LIKE '%' || :param || '%' ESCAPE '/'
```
Mit dem Wert von :param als "foo/%bar".
escape¶ –
ein Zeichen, das bei Angabe mit dem Schlüsselwort ESCAPE gerendert wird, um dieses Zeichen als Escape-Zeichen zu etablieren. Dieses Zeichen kann dann vor Vorkommen von % und _ gestellt werden, damit sie als sie selbst und nicht als Wildcard-Zeichen wirken.

Ein Ausdruck wie
```
somecolumn.contains("foo/%bar", escape="^")
```
Wird gerendert als
```
somecolumn LIKE '%' || :param || '%' ESCAPE '^'
```
Der Parameter kann auch mit ColumnOperators.contains.autoescape kombiniert werden
```
somecolumn.contains("foo%bar^bat", escape="^", autoescape=True)
```
Wo oben der angegebene literale Parameter zu "foo^%bar^^bat" konvertiert wird, bevor er an die Datenbank übergeben wird.

Siehe auch

ColumnOperators.startswith()

ColumnOperators.endswith()

ColumnOperators.startswith()

Methode sqlalchemy.orm.PropComparator.desc() → ColumnOperators¶: geerbt von der ColumnOperators.desc() Methode von ColumnOperators

Erzeugt eine desc() Klausel gegen das übergeordnete Objekt.

Methode sqlalchemy.orm.PropComparator.distinct() → ColumnOperators¶: geerbt von der ColumnOperators.distinct() Methode von ColumnOperators

Erzeugt eine distinct() Klausel gegen das übergeordnete Objekt.

Methode sqlalchemy.orm.PropComparator.endswith(other: Any, escape: str | None = None, autoescape: bool = False) → ColumnOperators¶

geerbt von der ColumnOperators.endswith() Methode von ColumnOperators

Implementiert den 'endswith'-Operator.

Erzeugt einen LIKE-Ausdruck, der gegen eine Übereinstimmung am Ende eines String-Wertes prüft.

column LIKE '%' || <other>

Z. B.

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

Da der Operator LIKE verwendet, verhalten sich die Wildcard-Zeichen "%" und "_", die im <other> Ausdruck vorhanden sind, ebenfalls wie Wildcards. Für literale Zeichenwerte kann das Flag ColumnOperators.endswith.autoescape auf True gesetzt werden, um Escape-Zeichen auf Vorkommen dieser Zeichen innerhalb des Zeichenwerts anzuwenden, damit sie als solche und nicht als Wildcard-Zeichen übereinstimmen. Alternativ etabliert der Parameter ColumnOperators.endswith.escape ein gegebenes Zeichen als Escape-Zeichen, was nützlich sein kann, wenn der Zielausdruck kein literaler Zeichenwert ist.

Parameter:

other¶ – zu vergleichender Ausdruck. Dies ist normalerweise ein einfacher Zeichenwert, kann aber auch ein beliebiger SQL-Ausdruck sein. LIKE-Wildcard-Zeichen % und _ werden standardmäßig nicht escaped, es sei denn, das Flag ColumnOperators.endswith.autoescape ist auf True gesetzt.
autoescape¶ –
Boolean; wenn True, wird ein Escape-Zeichen innerhalb des LIKE-Ausdrucks etabliert und dann auf alle Vorkommen von "%", "_" und des Escape-Zeichens selbst im Vergleichswert angewendet, der als literaler String und nicht als SQL-Ausdruck angenommen wird.

Ein Ausdruck wie
```
somecolumn.endswith("foo%bar", autoescape=True)
```
Wird gerendert als
```
somecolumn LIKE '%' || :param ESCAPE '/'
```
Mit dem Wert von :param als "foo/%bar".
escape¶ –
ein Zeichen, das bei Angabe mit dem Schlüsselwort ESCAPE gerendert wird, um dieses Zeichen als Escape-Zeichen zu etablieren. Dieses Zeichen kann dann vor Vorkommen von % und _ gestellt werden, damit sie als sie selbst und nicht als Wildcard-Zeichen wirken.

Ein Ausdruck wie
```
somecolumn.endswith("foo/%bar", escape="^")
```
Wird gerendert als
```
somecolumn LIKE '%' || :param ESCAPE '^'
```
Der Parameter kann auch mit ColumnOperators.endswith.autoescape kombiniert werden
```
somecolumn.endswith("foo%bar^bat", escape="^", autoescape=True)
```
Wo oben der angegebene literale Parameter zu "foo^%bar^^bat" konvertiert wird, bevor er an die Datenbank übergeben wird.

Siehe auch

ColumnOperators.contains()

ColumnOperators.contains()

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

Gibt einen SQL-Ausdruck zurück, der wahr ist, wenn dieses Element auf ein Mitglied verweist, das dem angegebenen Kriterium entspricht.

Die übliche Implementierung von has() ist Comparator.has().

Parameter:

criterion¶ – ein optionales ClauseElement, das auf der Tabelle oder den Attributen der Mitgliedsklasse formuliert ist.
**kwargs¶ – Schlüssel/Wert-Paare, die den Attributnamen der Mitgliedsklasse entsprechen und über Gleichheit mit den entsprechenden Werten verglichen werden.

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

geerbt von der ColumnOperators.icontains() Methode von ColumnOperators

Implementiert den Operator icontains, z.B. die Groß-/Kleinschreibung ignorierende Version von ColumnOperators.contains().

Erzeugt einen LIKE-Ausdruck, der gegen eine unempfindliche Übereinstimmung in der Mitte eines Zeichenkettenwerts testet.

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

Z. B.

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

Da der Operator LIKE verwendet, verhalten sich die Wildcard-Zeichen "%" und "_", die im <other> Ausdruck vorhanden sind, ebenfalls wie Wildcards. Für literale Zeichenwerte kann das Flag ColumnOperators.icontains.autoescape auf True gesetzt werden, um Escape-Zeichen auf Vorkommen dieser Zeichen innerhalb des Zeichenwerts anzuwenden, damit sie als solche und nicht als Wildcard-Zeichen übereinstimmen. Alternativ etabliert der Parameter ColumnOperators.icontains.escape ein gegebenes Zeichen als Escape-Zeichen, was nützlich sein kann, wenn der Zielausdruck kein literaler Zeichenwert ist.

Parameter:

other¶ – zu vergleichender Ausdruck. Dies ist normalerweise ein einfacher Zeichenwert, kann aber auch ein beliebiger SQL-Ausdruck sein. LIKE-Wildcard-Zeichen % und _ werden standardmäßig nicht escaped, es sei denn, das Flag ColumnOperators.icontains.autoescape ist auf True gesetzt.
autoescape¶ –
Boolean; wenn True, wird ein Escape-Zeichen innerhalb des LIKE-Ausdrucks etabliert und dann auf alle Vorkommen von "%", "_" und des Escape-Zeichens selbst im Vergleichswert angewendet, der als literaler String und nicht als SQL-Ausdruck angenommen wird.

Ein Ausdruck wie
```
somecolumn.icontains("foo%bar", autoescape=True)
```
Wird gerendert als
```
lower(somecolumn) LIKE '%' || lower(:param) || '%' ESCAPE '/'
```
Mit dem Wert von :param als "foo/%bar".
escape¶ –
ein Zeichen, das bei Angabe mit dem Schlüsselwort ESCAPE gerendert wird, um dieses Zeichen als Escape-Zeichen zu etablieren. Dieses Zeichen kann dann vor Vorkommen von % und _ gestellt werden, damit sie als sie selbst und nicht als Wildcard-Zeichen wirken.

Ein Ausdruck wie
```
somecolumn.icontains("foo/%bar", escape="^")
```
Wird gerendert als
```
lower(somecolumn) LIKE '%' || lower(:param) || '%' ESCAPE '^'
```
Der Parameter kann auch mit ColumnOperators.contains.autoescape kombiniert werden
```
somecolumn.icontains("foo%bar^bat", escape="^", autoescape=True)
```
Wo oben der angegebene literale Parameter zu "foo^%bar^^bat" konvertiert wird, bevor er an die Datenbank übergeben wird.

Siehe auch

Methode sqlalchemy.orm.PropComparator.iendswith(other: Any, escape: str | None = None, autoescape: bool = False) → ColumnOperators¶

geerbt von der ColumnOperators.iendswith() Methode von ColumnOperators

Implementiert den Operator iendswith, z.B. die Groß-/Kleinschreibung ignorierende Version von ColumnOperators.endswith().

Erzeugt einen LIKE-Ausdruck, der gegen eine unempfindliche Übereinstimmung am Ende eines Zeichenkettenwerts testet.

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

Z. B.

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

Da der Operator LIKE verwendet, verhalten sich die Wildcard-Zeichen "%" und "_", die im <other> Ausdruck vorhanden sind, ebenfalls wie Wildcards. Für literale Zeichenwerte kann das Flag ColumnOperators.iendswith.autoescape auf True gesetzt werden, um Escape-Zeichen auf Vorkommen dieser Zeichen innerhalb des Zeichenwerts anzuwenden, damit sie als solche und nicht als Wildcard-Zeichen übereinstimmen. Alternativ etabliert der Parameter ColumnOperators.iendswith.escape ein gegebenes Zeichen als Escape-Zeichen, was nützlich sein kann, wenn der Zielausdruck kein literaler Zeichenwert ist.

Parameter:

other¶ – zu vergleichender Ausdruck. Dies ist normalerweise ein einfacher Zeichenwert, kann aber auch ein beliebiger SQL-Ausdruck sein. LIKE-Wildcard-Zeichen % und _ werden standardmäßig nicht escaped, es sei denn, das Flag ColumnOperators.iendswith.autoescape ist auf True gesetzt.
autoescape¶ –
Boolean; wenn True, wird ein Escape-Zeichen innerhalb des LIKE-Ausdrucks etabliert und dann auf alle Vorkommen von "%", "_" und des Escape-Zeichens selbst im Vergleichswert angewendet, der als literaler String und nicht als SQL-Ausdruck angenommen wird.

Ein Ausdruck wie
```
somecolumn.iendswith("foo%bar", autoescape=True)
```
Wird gerendert als
```
lower(somecolumn) LIKE '%' || lower(:param) ESCAPE '/'
```
Mit dem Wert von :param als "foo/%bar".
escape¶ –
ein Zeichen, das bei Angabe mit dem Schlüsselwort ESCAPE gerendert wird, um dieses Zeichen als Escape-Zeichen zu etablieren. Dieses Zeichen kann dann vor Vorkommen von % und _ gestellt werden, damit sie als sie selbst und nicht als Wildcard-Zeichen wirken.

Ein Ausdruck wie
```
somecolumn.iendswith("foo/%bar", escape="^")
```
Wird gerendert als
```
lower(somecolumn) LIKE '%' || lower(:param) ESCAPE '^'
```
Der Parameter kann auch mit ColumnOperators.iendswith.autoescape kombiniert werden
```
somecolumn.endswith("foo%bar^bat", escape="^", autoescape=True)
```
Wo oben der angegebene literale Parameter zu "foo^%bar^^bat" konvertiert wird, bevor er an die Datenbank übergeben wird.

Siehe auch

ColumnOperators.endswith()

Methode sqlalchemy.orm.PropComparator.ilike(other: Any, escape: str | None = None) → ColumnOperators¶

geerbt von der ColumnOperators.ilike() Methode von ColumnOperators

Implementiert den ilike Operator, z. B. die Groß-/Kleinschreibung-unabhängige LIKE-Abfrage.

In einem Spaltenkontext wird ein Ausdruck erzeugt, entweder in der Form

lower(a) LIKE lower(other)

Oder auf Backends, die den ILIKE-Operator unterstützen

a ILIKE other

Z. B.

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

Parameter:

other¶ – zu vergleichender Ausdruck
escape¶ –
optionales Escape-Zeichen, rendert das ESCAPE Schlüsselwort, z. B.
```
somecolumn.ilike("foo/%bar", escape="/")
```

Siehe auch

ColumnOperators.is_not()

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

geerbt von der ColumnOperators.in_() Methode von ColumnOperators

Implementiert den in Operator.

In einem Spaltenkontext wird die Klausel column IN <other> erzeugt.

Der angegebene Parameter other kann sein

Eine Liste von literalen Werten, z. B.
```
stmt.where(column.in_([1, 2, 3]))
```
In dieser Aufrufform wird die Liste der Elemente in eine Menge von gebundenen Parametern der gleichen Länge wie die angegebene Liste umgewandelt.
```
WHERE COL IN (?, ?, ?)
```
Eine Liste von Tupeln kann bereitgestellt werden, wenn der Vergleich gegen ein tuple_() mit mehreren Ausdrücken erfolgt
```
from sqlalchemy import tuple_

stmt.where(tuple_(col1, col2).in_([(1, 10), (2, 20), (3, 30)]))
```
Eine leere Liste, z. B.
```
stmt.where(column.in_([]))
```
In dieser Aufrufform rendert der Ausdruck einen "leeren Mengen"-Ausdruck. Diese Ausdrücke sind auf einzelne Backends zugeschnitten und versuchen im Allgemeinen, eine leere SELECT-Anweisung als Unterabfrage zu erhalten. Auf SQLite ist der Ausdruck
```
WHERE col IN (SELECT 1 FROM (SELECT 1) WHERE 1!=1)
```
Geändert in Version 1.4: Leere IN-Ausdrücke verwenden nun in allen Fällen eine zur Laufzeit generierte SELECT-Unterabfrage.
Ein gebundener Parameter, z.B. bindparam(), kann verwendet werden, wenn er das Flag bindparam.expanding enthält
```
stmt.where(column.in_(bindparam("value", expanding=True)))
```
In dieser Aufrufform rendert der Ausdruck einen speziellen nicht-SQL-Platzhalter-Ausdruck, der wie folgt aussieht:
```
WHERE COL IN ([EXPANDING_value])
```
Dieser Platzhalter-Ausdruck wird zur Laufzeit der Anweisung abgefangen und in die variable Anzahl von gebundenen Parametern umgewandelt, wie zuvor gezeigt. Wenn die Anweisung ausgeführt würde als
```
connection.execute(stmt, {"value": [1, 2, 3]})
```
Die Datenbank würde für jeden Wert einen gebundenen Parameter erhalten.
```
WHERE COL IN (?, ?, ?)
```
Neu in Version 1.2: "expanding" gebundene Parameter hinzugefügt.

Wenn eine leere Liste übergeben wird, wird ein spezieller "leere Liste"-Ausdruck gerendert, der für die verwendete Datenbank spezifisch ist. Auf SQLite wäre dies
```
WHERE COL IN (SELECT 1 FROM (SELECT 1) WHERE 1!=1)
```
Neu in Version 1.3: "expanding" gebundene Parameter unterstützen nun leere Listen.

ein select() Konstrukt, was normalerweise ein korrelierter Skalar-Select ist

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

In dieser Aufrufform wird ColumnOperators.in_() wie angegeben gerendert

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

Parameter:: other¶ – eine Liste von Literalen, ein select() Konstrukt oder ein bindparam() Konstrukt, das das Flag bindparam.expanding auf True gesetzt enthält.

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

geerbt von der ColumnOperators.is_() Methode von ColumnOperators

Implementiert den IS Operator.

Normalerweise wird IS automatisch generiert, wenn mit einem Wert von None verglichen wird, was zu NULL aufgelöst wird. Eine explizite Verwendung von IS kann jedoch wünschenswert sein, wenn auf bestimmten Plattformen mit booleschen Werten verglichen wird.

Siehe auch

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

geerbt von der ColumnOperators.is_distinct_from() Methode von ColumnOperators

Implementiert den IS DISTINCT FROM Operator.

Rendert auf den meisten Plattformen "a IS DISTINCT FROM b"; auf einigen wie SQLite möglicherweise "a IS NOT b".

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

geerbt von der ColumnOperators.is_not() Methode von ColumnOperators

Implementiert den IS NOT Operator.

Normalerweise wird IS NOT automatisch generiert, wenn mit einem Wert von None verglichen wird, was zu NULL aufgelöst wird. Eine explizite Verwendung von IS NOT kann jedoch wünschenswert sein, wenn auf bestimmten Plattformen mit booleschen Werten verglichen wird.

Geändert in Version 1.4: Der is_not() Operator wurde von isnot() in früheren Versionen umbenannt. Der vorherige Name bleibt aus Kompatibilitätsgründen erhalten.

Siehe auch

ColumnOperators.is_()

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

geerbt von der ColumnOperators.is_not_distinct_from() Methode von ColumnOperators

Implementiert den IS NOT DISTINCT FROM Operator.

Rendert auf den meisten Plattformen "a IS NOT DISTINCT FROM b"; auf einigen wie SQLite möglicherweise "a IS b".

Geändert in Version 1.4: Der is_not_distinct_from() Operator wurde von isnot_distinct_from() in früheren Versionen umbenannt. Der vorherige Name bleibt aus Kompatibilitätsgründen erhalten.

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

geerbt von der ColumnOperators.isnot() Methode von ColumnOperators

Implementiert den IS NOT Operator.

Normalerweise wird IS NOT automatisch generiert, wenn mit einem Wert von None verglichen wird, was zu NULL aufgelöst wird. Eine explizite Verwendung von IS NOT kann jedoch wünschenswert sein, wenn auf bestimmten Plattformen mit booleschen Werten verglichen wird.

Geändert in Version 1.4: Der is_not() Operator wurde von isnot() in früheren Versionen umbenannt. Der vorherige Name bleibt aus Kompatibilitätsgründen erhalten.

Siehe auch

ColumnOperators.is_()

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

geerbt von der ColumnOperators.isnot_distinct_from() Methode von ColumnOperators

Implementiert den IS NOT DISTINCT FROM Operator.

Rendert auf den meisten Plattformen "a IS NOT DISTINCT FROM b"; auf einigen wie SQLite möglicherweise "a IS b".

Geändert in Version 1.4: Der is_not_distinct_from() Operator wurde von isnot_distinct_from() in früheren Versionen umbenannt. Der vorherige Name bleibt aus Kompatibilitätsgründen erhalten.

Methode sqlalchemy.orm.PropComparator.istartswith(other: Any, escape: str | None = None, autoescape: bool = False) → ColumnOperators¶

geerbt von der ColumnOperators.istartswith() Methode von ColumnOperators

Implementieren Sie den Operator istartswith, z. B. eine Groß-/Kleinschreibungs-unempfindliche Version von ColumnOperators.startswith().

Erzeugt einen LIKE-Ausdruck, der gegen eine unempfindliche Übereinstimmung am Anfang eines Zeichenkettenwerts testet.

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

Z. B.

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

Da der Operator LIKE verwendet, verhalten sich Platzhalterzeichen "%" und "_", die im <other>-Ausdruck vorhanden sind, ebenfalls wie Platzhalter. Für literale Zeichenkettenwerte kann das Flag ColumnOperators.istartswith.autoescape auf True gesetzt werden, um Vorkommen dieser Zeichen innerhalb des Zeichenkettenwerts zu maskieren, damit sie als sich selbst und nicht als Platzhalter übereinstimmen. Alternativ legt der Parameter ColumnOperators.istartswith.escape ein bestimmtes Zeichen als Escape-Zeichen fest, was nützlich sein kann, wenn der Zielausdruck keine literale Zeichenkette ist.

Parameter:

other¶ – Ausdruck, der verglichen werden soll. Dies ist normalerweise ein einfacher Zeichenkettenwert, kann aber auch ein beliebiger SQL-Ausdruck sein. LIKE-Platzhalterzeichen % und _ werden standardmäßig nicht maskiert, es sei denn, das Flag ColumnOperators.istartswith.autoescape ist auf True gesetzt.
autoescape¶ –
Boolean; wenn True, wird ein Escape-Zeichen innerhalb des LIKE-Ausdrucks etabliert und dann auf alle Vorkommen von "%", "_" und des Escape-Zeichens selbst im Vergleichswert angewendet, der als literaler String und nicht als SQL-Ausdruck angenommen wird.

Ein Ausdruck wie
```
somecolumn.istartswith("foo%bar", autoescape=True)
```
Wird gerendert als
```
lower(somecolumn) LIKE lower(:param) || '%' ESCAPE '/'
```
Mit dem Wert von :param als "foo/%bar".
escape¶ –
ein Zeichen, das bei Angabe mit dem Schlüsselwort ESCAPE gerendert wird, um dieses Zeichen als Escape-Zeichen zu etablieren. Dieses Zeichen kann dann vor Vorkommen von % und _ gestellt werden, damit sie als sie selbst und nicht als Wildcard-Zeichen wirken.

Ein Ausdruck wie
```
somecolumn.istartswith("foo/%bar", escape="^")
```
Wird gerendert als
```
lower(somecolumn) LIKE lower(:param) || '%' ESCAPE '^'
```
Der Parameter kann auch mit ColumnOperators.istartswith.autoescape kombiniert werden
```
somecolumn.istartswith("foo%bar^bat", escape="^", autoescape=True)
```
Wo oben der angegebene literale Parameter zu "foo^%bar^^bat" konvertiert wird, bevor er an die Datenbank übergeben wird.

Siehe auch

ColumnOperators.startswith()

methode sqlalchemy.orm.PropComparator.like(other: Any, escape: str | None = None) → ColumnOperators¶

geerbt von der ColumnOperators.like()-Methode von ColumnOperators

Implementiert den like Operator.

In einem Spaltenkontext wird der Ausdruck erzeugt

a LIKE other

Z. B.

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

Parameter:

other¶ – Ausdruck, der verglichen werden soll
escape¶ –
optionales Escape-Zeichen, rendert das ESCAPE Schlüsselwort, z. B.
```
somecolumn.like("foo/%bar", escape="/")
```

Siehe auch

ColumnOperators.ilike()

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

geerbt von der ColumnOperators.match()-Methode von ColumnOperators

Implementiert einen datenbankspezifischen 'match'-Operator.

ColumnOperators.match() versucht, auf eine MATCH-ähnliche Funktion oder einen Operator aufzulösen, der vom Backend bereitgestellt wird. Beispiele hierfür sind

PostgreSQL - rendert x @@ plainto_tsquery(y)

Geändert in Version 2.0: plainto_tsquery() wird jetzt anstelle von to_tsquery() für PostgreSQL verwendet; für Kompatibilität mit anderen Formen siehe Volltextsuche.
MySQL - rendert MATCH (x) AGAINST (y IN BOOLEAN MODE)

Siehe auch

match - MySQL-spezifische Konstruktion mit zusätzlichen Funktionen.
Oracle Database - rendert CONTAINS(x, y)
andere Backends können spezielle Implementierungen bereitstellen.
Backends ohne spezielle Implementierung geben den Operator als „MATCH“ aus. Dies ist beispielsweise mit SQLite kompatibel.

methode sqlalchemy.orm.PropComparator.not_ilike(other: Any, escape: str | None = None) → ColumnOperators¶

geerbt von der ColumnOperators.not_ilike()-Methode von ColumnOperators

Implementiert den NOT ILIKE Operator.

Dies entspricht der Verwendung der Negation mit ColumnOperators.ilike(), d. h. ~x.ilike(y).

Geändert in Version 1.4: Der Operator not_ilike() wurde von notilike() in früheren Versionen umbenannt. Der vorherige Name bleibt für Abwärtskompatibilität verfügbar.

Siehe auch

ColumnOperators.ilike()

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

geerbt von der ColumnOperators.not_in()-Methode von ColumnOperators

Implementiert den NOT IN Operator.

Dies entspricht der Verwendung der Negation mit ColumnOperators.in_(), d. h. ~x.in_(y).

Wenn other eine leere Sequenz ist, erzeugt der Compiler einen "leeren nicht in"-Ausdruck. Dies ist standardmäßig der Ausdruck "1 = 1", um in allen Fällen true zu ergeben. Die create_engine.empty_in_strategy kann verwendet werden, um dieses Verhalten zu ändern.

Geändert in Version 1.4: Der Operator not_in() wurde von notin_() in früheren Versionen umbenannt. Der vorherige Name bleibt für Abwärtskompatibilität verfügbar.

Geändert in Version 1.2: Die Operatoren ColumnOperators.in_() und ColumnOperators.not_in() erzeugen nun standardmäßig einen "statischen" Ausdruck für eine leere IN-Sequenz.

Siehe auch

ColumnOperators.in_()

methode sqlalchemy.orm.PropComparator.not_like(other: Any, escape: str | None = None) → ColumnOperators¶

geerbt von der ColumnOperators.not_like()-Methode von ColumnOperators

Implementiert den NOT LIKE Operator.

Dies entspricht der Verwendung der Negation mit ColumnOperators.like(), d. h. ~x.like(y).

Geändert in Version 1.4: Der Operator not_like() wurde von notlike() in früheren Versionen umbenannt. Der vorherige Name bleibt für Abwärtskompatibilität verfügbar.

Siehe auch

ColumnOperators.ilike()

methode sqlalchemy.orm.PropComparator.notilike(other: Any, escape: str | None = None) → ColumnOperators¶

geerbt von der ColumnOperators.notilike()-Methode von ColumnOperators

Implementiert den NOT ILIKE Operator.

Dies entspricht der Verwendung der Negation mit ColumnOperators.ilike(), d. h. ~x.ilike(y).

Geändert in Version 1.4: Der Operator not_ilike() wurde von notilike() in früheren Versionen umbenannt. Der vorherige Name bleibt für Abwärtskompatibilität verfügbar.

Siehe auch

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

geerbt von der ColumnOperators.notin_()-Methode von ColumnOperators

Implementiert den NOT IN Operator.

Dies entspricht der Verwendung der Negation mit ColumnOperators.in_(), d. h. ~x.in_(y).

Wenn other eine leere Sequenz ist, erzeugt der Compiler einen "leeren nicht in"-Ausdruck. Dies ist standardmäßig der Ausdruck "1 = 1", um in allen Fällen true zu ergeben. Die create_engine.empty_in_strategy kann verwendet werden, um dieses Verhalten zu ändern.

Geändert in Version 1.4: Der Operator not_in() wurde von notin_() in früheren Versionen umbenannt. Der vorherige Name bleibt für Abwärtskompatibilität verfügbar.

Geändert in Version 1.2: Die Operatoren ColumnOperators.in_() und ColumnOperators.not_in() erzeugen nun standardmäßig einen "statischen" Ausdruck für eine leere IN-Sequenz.

Siehe auch

ColumnOperators.in_()

methode sqlalchemy.orm.PropComparator.notlike(other: Any, escape: str | None = None) → ColumnOperators¶

geerbt von der ColumnOperators.notlike()-Methode von ColumnOperators

Implementiert den NOT LIKE Operator.

Dies entspricht der Verwendung der Negation mit ColumnOperators.like(), d. h. ~x.like(y).

Geändert in Version 1.4: Der Operator not_like() wurde von notlike() in früheren Versionen umbenannt. Der vorherige Name bleibt für Abwärtskompatibilität verfügbar.

Siehe auch

Verwenden von Beziehungen zum Verknüpfen zwischen alias-Zielen - im ORM-Abfragehandbuch

methode sqlalchemy.orm.PropComparator.nulls_first() → ColumnOperators¶: geerbt von der ColumnOperators.nulls_first()-Methode von ColumnOperators

Erzeugt eine nulls_first()-Klausel für das übergeordnete Objekt.

Geändert in Version 1.4: Der Operator nulls_first() wurde von nullsfirst() in früheren Versionen umbenannt. Der vorherige Name bleibt für Abwärtskompatibilität verfügbar.

methode sqlalchemy.orm.PropComparator.nulls_last() → ColumnOperators¶: geerbt von der ColumnOperators.nulls_last()-Methode von ColumnOperators

Erzeugt eine nulls_last()-Klausel für das übergeordnete Objekt.

Geändert in Version 1.4: Der Operator nulls_last() wurde von nullslast() in früheren Versionen umbenannt. Der vorherige Name bleibt für Abwärtskompatibilität verfügbar.

methode sqlalchemy.orm.PropComparator.nullsfirst() → ColumnOperators¶: geerbt von der ColumnOperators.nullsfirst()-Methode von ColumnOperators

Erzeugt eine nulls_first()-Klausel für das übergeordnete Objekt.

Geändert in Version 1.4: Der Operator nulls_first() wurde von nullsfirst() in früheren Versionen umbenannt. Der vorherige Name bleibt für Abwärtskompatibilität verfügbar.

methode sqlalchemy.orm.PropComparator.nullslast() → ColumnOperators¶: geerbt von der ColumnOperators.nullslast()-Methode von ColumnOperators

Erzeugt eine nulls_last()-Klausel für das übergeordnete Objekt.

Geändert in Version 1.4: Der Operator nulls_last() wurde von nullslast() in früheren Versionen umbenannt. Der vorherige Name bleibt für Abwärtskompatibilität verfügbar.

methode sqlalchemy.orm.PropComparator.of_type(class_: _EntityType[Any]) → PropComparator[_T_co]¶

Definieren Sie dieses Objekt neu in Form eines polymorphen Unterklassenkonstrukts, eines with_polymorphic()-Konstrukts oder eines aliased()-Konstrukts.

Gibt einen neuen PropComparator zurück, von dem aus weitere Kriterien ausgewertet werden können.

z. B.

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

Parameter:: class_¶ – eine Klasse oder ein Mapper, der angibt, dass die Kriterien gegen diese spezielle Unterklasse ausgewertet werden.

Siehe auch

Verknüpfen mit spezifischen Untertypen oder with_polymorphic()-Entitäten

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

geerbt von der Operators.op()-Methode von Operators

Erzeugt eine generische Operatorfunktion.

z. B.

somecolumn.op("*")(5)

produziert

somecolumn * 5

Diese Funktion kann auch verwendet werden, um bitweise Operatoren explizit zu machen. Zum Beispiel

somecolumn.op("&")(0xFF)

ist ein bitweises UND des Wertes in somecolumn.

Parameter:

opstring¶ – eine Zeichenkette, die als Infix-Operator zwischen diesem Element und dem an die generierte Funktion übergebenen Ausdruck ausgegeben wird.
precedence¶ –
die Priorität, die die Datenbank erwartungsgemäß auf den Operator in SQL-Ausdrücken anwenden soll. Dieser ganzzahlige Wert dient als Hinweis für den SQL-Compiler, wann explizite Klammern um eine bestimmte Operation gerendert werden sollen. Ein niedrigerer Wert führt dazu, dass der Ausdruck bei der Anwendung auf einen anderen Operator mit höherer Priorität geklammert wird. Der Standardwert von 0 ist niedriger als alle Operatoren, außer dem Komma (,) und dem AS Operator. Ein Wert von 100 ist höher oder gleich allen Operatoren und -100 ist niedriger oder gleich allen Operatoren.

Siehe auch

Ich verwende op() zur Erzeugung eines benutzerdefinierten Operators und meine Klammern werden nicht richtig ausgegeben - detaillierte Beschreibung, wie der SQLAlchemy SQL-Compiler Klammern rendert
is_comparison¶ –
veraltet; wenn True, wird der Operator als "Vergleichsoperator" betrachtet, d. h. er ergibt einen booleschen Wahr/Falsch-Wert, wie z. B. ==, > usw. Dieses Flag wird bereitgestellt, damit ORM-Beziehungen feststellen können, dass der Operator ein Vergleichsoperator ist, wenn er in einer benutzerdefinierten Join-Bedingung verwendet wird.

Die Verwendung des Parameters is_comparison wird durch die Verwendung der Methode Operators.bool_op() ersetzt; dieser kürzere Operator setzt diesen Parameter automatisch, bietet aber auch korrekte PEP 484-Typunterstützung, da das zurückgegebene Objekt einen "booleschen" Datentyp ausdrückt, d. h. BinaryExpression[bool].
return_type¶ – eine TypeEngine-Klasse oder ein Objekt, das den Rückgabetyp eines von diesem Operator erzeugten Ausdrucks auf diesen Typ erzwingt. Standardmäßig werden Operatoren, die Operators.op.is_comparison angeben, zu Boolean aufgelöst, und solche, die dies nicht tun, haben den gleichen Typ wie der linke Operand.
python_impl¶ –
eine optionale Python-Funktion, die zwei Python-Werte auf die gleiche Weise auswerten kann, wie dieser Operator auf dem Datenbankserver funktioniert. Nützlich für die SQL-Ausdrucksauswertung innerhalb von Python, z. B. für ORM-Hybridattribute und den ORM "Evaluator", der verwendet wird, um Objekte in einer Sitzung nach einem Mehrzeilen-Update oder -Löschvorgang abzugleichen.

z. B.
```
>>> expr = column("x").op("+", python_impl=lambda a, b: a + b)("y")
```
Der Operator für den obigen Ausdruck funktioniert auch für nicht-SQL-linke und rechte Objekte
```
>>> expr.operator(5, 10)
15
```
Neu in Version 2.0.

Siehe auch

Operators.bool_op()

Verwendung benutzerdefinierter Operatoren in Verknüpfungsbedingungen

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

geerbt von der Operators.operate()-Methode von Operators

Operiert auf einem Argument.

Dies ist die niedrigste Ebene der Operation, löst standardmäßig NotImplementedError aus.

Das Überschreiben dieser Methode in einer Unterklasse kann dazu dienen, ein gemeinsames Verhalten auf alle Operationen anzuwenden. Zum Beispiel kann das Überschreiben von ColumnOperators dazu dienen, func.lower() auf die linke und rechte Seite anzuwenden.

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

Parameter:

op¶ – Operator aufrufbar.
*other¶ – die "andere" Seite der Operation. Für die meisten Operationen wird dies ein einzelner Skalar sein.
**kwargs¶ – Modifikatoren. Diese können von speziellen Operatoren wie ColumnOperators.contains() übergeben werden.

attribut sqlalchemy.orm.PropComparator.property¶

Gibt die zu diesem PropComparator zugehörige MapperProperty zurück.

Die Rückgabewerte sind hier üblicherweise Instanzen von ColumnProperty oder Relationship.

methode sqlalchemy.orm.PropComparator.regexp_match(pattern: Any, flags: str | None = None) → ColumnOperators¶

geerbt von der ColumnOperators.regexp_match()-Methode von ColumnOperators

Implementiert einen datenbankspezifischen „regexp match“-Operator.

Z. B.

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

ColumnOperators.regexp_match() versucht, auf eine REGEXP-ähnliche Funktion oder einen Operator aufzulösen, der vom Backend bereitgestellt wird. **Die spezifische reguläre Ausdruckssyntax und die verfügbaren Flags sind jedoch nicht Backend-agnostisch.**

Beispiele hierfür sind:

PostgreSQL - rendert x ~ y oder x !~ y bei Negation.
Oracle Database - rendert REGEXP_LIKE(x, y)
SQLite - verwendet den Platzhalteroperator REGEXP von SQLite und ruft die Python-Builtin-Funktion re.match() auf.
andere Backends können spezielle Implementierungen bereitstellen.
Backends ohne spezielle Implementierung geben den Operator als „REGEXP“ oder „NOT REGEXP“ aus. Dies ist beispielsweise mit SQLite und MySQL kompatibel.

Reguläre Ausdrucksunterstützung ist derzeit für Oracle Database, PostgreSQL, MySQL und MariaDB implementiert. Teilweise Unterstützung ist für SQLite verfügbar. Die Unterstützung bei Drittanbieter-Dialekten kann variieren.

Parameter:

pattern¶ – Die reguläre Ausdrucksmusterzeichenkette oder Spaltenklausel.
flags¶ – Jegliche regulären Ausdrucks-Flags, die angewendet werden sollen, nur als einfacher Python-String übergeben. Diese Flags sind Backend-spezifisch. Einige Backends, wie PostgreSQL und MariaDB, können die Flags alternativ als Teil des Musters angeben. Bei Verwendung des „ignore case“-Flags „i“ in PostgreSQL wird der Operator für den Groß-/Kleinschreibung ignorierenden regulären Ausdrucksabgleich ~* oder !~* verwendet.

Neu in Version 1.4.

Geändert in Version 1.4.48,: 2.0.18 Aufgrund eines Implementierungsfehlers akzeptierte der Parameter „flags“ zuvor SQL-Ausdrucksobjekte wie Spaltenausdrücke zusätzlich zu einfachen Python-Strings. Diese Implementierung funktionierte nicht korrekt mit Caching und wurde entfernt; es sollten nur Strings für den Parameter „flags“ übergeben werden, da diese Flags als wörtliche Inline-Werte innerhalb von SQL-Ausdrücken gerendert werden.

Siehe auch

ColumnOperators.regexp_replace()

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

geerbt von der ColumnOperators.regexp_replace() Methode von ColumnOperators

Implementiert einen datenbankspezifischen „regexp replace“-Operator.

Z. B.

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

ColumnOperators.regexp_replace() versucht, eine REGEXP_REPLACE-ähnliche Funktion des Backends zu lösen, die normalerweise die Funktion REGEXP_REPLACE() ausgibt. Die spezifische Syntax regulärer Ausdrücke und die verfügbaren Flags sind jedoch **nicht Backend-agnostisch**.

Unterstützung für reguläre Ersetzungen ist derzeit für Oracle Database, PostgreSQL, MySQL 8 oder höher und MariaDB implementiert. Die Unterstützung bei Drittanbieter-Dialekten kann variieren.

Parameter:

pattern¶ – Der String des regulären Ausdrucksmusters oder die Spaltenklausel.
pattern¶ – Der Ersetzungsstring oder die Spaltenklausel.
flags¶ – Jegliche regulären Ausdrucks-Flags, die angewendet werden sollen, nur als einfacher Python-String übergeben. Diese Flags sind Backend-spezifisch. Einige Backends, wie PostgreSQL und MariaDB, können die Flags alternativ als Teil des Musters angeben.

Neu in Version 1.4.

Geändert in Version 1.4.48,: 2.0.18 Aufgrund eines Implementierungsfehlers akzeptierte der Parameter „flags“ zuvor SQL-Ausdrucksobjekte wie Spaltenausdrücke zusätzlich zu einfachen Python-Strings. Diese Implementierung funktionierte nicht korrekt mit Caching und wurde entfernt; es sollten nur Strings für den Parameter „flags“ übergeben werden, da diese Flags als wörtliche Inline-Werte innerhalb von SQL-Ausdrücken gerendert werden.

Siehe auch

ColumnOperators.regexp_match()

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

geerbt von der Operators.reverse_operate() Methode von Operators

Umgekehrte Operation auf ein Argument.

Die Verwendung ist die gleiche wie bei operate().

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

geerbt von der ColumnOperators.startswith() Methode von ColumnOperators

Implementiert den Operator startswith.

Erzeugt einen LIKE-Ausdruck, der gegen eine Übereinstimmung mit dem Anfang eines String-Wertes testet.

column LIKE <other> || '%'

Z. B.

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

Da der Operator LIKE verwendet, verhalten sich Wildcard-Zeichen "%" und "_", die im Ausdruck <other> vorkommen, ebenfalls als Wildcards. Für literale Zeichenkettenwerte kann das Flag ColumnOperators.startswith.autoescape auf True gesetzt werden, um diese Zeichen im Zeichenkettenwert zu maskieren, damit sie als sie selbst und nicht als Wildcard-Zeichen übereinstimmen. Alternativ legt der Parameter ColumnOperators.startswith.escape ein gegebenes Zeichen als Escape-Zeichen fest, was nützlich sein kann, wenn der Zielausdruck keine literale Zeichenkette ist.

Parameter:

other¶ – Ausdruck, der verglichen werden soll. Dies ist normalerweise ein einfacher Zeichenkettenwert, kann aber auch ein beliebiger SQL-Ausdruck sein. LIKE-Wildcard-Zeichen % und _ werden standardmäßig nicht maskiert, es sei denn, das Flag ColumnOperators.startswith.autoescape ist auf True gesetzt.
autoescape¶ –
Boolean; wenn True, wird ein Escape-Zeichen innerhalb des LIKE-Ausdrucks etabliert und dann auf alle Vorkommen von "%", "_" und des Escape-Zeichens selbst im Vergleichswert angewendet, der als literaler String und nicht als SQL-Ausdruck angenommen wird.

Ein Ausdruck wie
```
somecolumn.startswith("foo%bar", autoescape=True)
```
Wird gerendert als
```
somecolumn LIKE :param || '%' ESCAPE '/'
```
Mit dem Wert von :param als "foo/%bar".
escape¶ –
ein Zeichen, das bei Angabe mit dem Schlüsselwort ESCAPE gerendert wird, um dieses Zeichen als Escape-Zeichen zu etablieren. Dieses Zeichen kann dann vor Vorkommen von % und _ gestellt werden, damit sie als sie selbst und nicht als Wildcard-Zeichen wirken.

Ein Ausdruck wie
```
somecolumn.startswith("foo/%bar", escape="^")
```
Wird gerendert als
```
somecolumn LIKE :param || '%' ESCAPE '^'
```
Der Parameter kann auch mit ColumnOperators.startswith.autoescape kombiniert werden.
```
somecolumn.startswith("foo%bar^bat", escape="^", autoescape=True)
```
Wo oben der angegebene literale Parameter zu "foo^%bar^^bat" konvertiert wird, bevor er an die Datenbank übergeben wird.

Siehe auch

ColumnOperators.endswith()

ColumnOperators.contains()

attribute sqlalchemy.orm.PropComparator.timetuple: Literal[None] = None¶: geerbt von der ColumnOperators.timetuple Attribut von ColumnOperators

Hack, erlaubt den Vergleich von Datetime-Objekten auf der linken Seite.

class sqlalchemy.orm.Relationship¶

Beschreibt eine Objekt-Eigenschaft, die ein einzelnes Element oder eine Liste von Elementen enthält, die einer zugehörigen Datenbanktabelle entsprechen.

Der öffentliche Konstruktor ist die Funktion relationship().

Siehe auch

Beziehungskonfiguration

Geändert in Version 2.0: Relationship wurde als deklarationskompatible Unterklasse für RelationshipProperty hinzugefügt.

Klassensignatur

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

class sqlalchemy.orm.RelationshipDirection¶

Aufzählung, die die „Richtung“ einer RelationshipProperty angibt.

RelationshipDirection ist vom Attribut Relationship.direction von RelationshipProperty aus zugänglich.

Mitglieder

MANYTOMANY, MANYTOONE, ONETOMANY

Klassensignatur

class sqlalchemy.orm.RelationshipDirection (enum.Enum)

attribute sqlalchemy.orm.RelationshipDirection.MANYTOMANY = 3¶

Gibt die Many-to-Many-Richtung für eine relationship() an.

Dieses Symbol wird typischerweise von der internen Logik verwendet, kann aber in bestimmten API-Funktionen exponiert sein.

attribute sqlalchemy.orm.RelationshipDirection.MANYTOONE = 2¶

Gibt die Many-to-One-Richtung für eine relationship() an.

Dieses Symbol wird typischerweise von der internen Logik verwendet, kann aber in bestimmten API-Funktionen exponiert sein.

attribute sqlalchemy.orm.RelationshipDirection.ONETOMANY = 1¶

Gibt die One-to-Many-Richtung für eine relationship() an.

Dieses Symbol wird typischerweise von der internen Logik verwendet, kann aber in bestimmten API-Funktionen exponiert sein.

class sqlalchemy.orm.RelationshipProperty¶

Beschreibt eine Objekt-Eigenschaft, die ein einzelnes Element oder eine Liste von Elementen enthält, die einer zugehörigen Datenbanktabelle entsprechen.

Der öffentliche Konstruktor ist die Funktion relationship().

Siehe auch

Beziehungskonfiguration

Mitglieder

__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()

Klassensignatur

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

class Comparator¶

Erzeugt boolesche, Vergleichs- und andere Operatoren für RelationshipProperty Attribute.

Siehe die Dokumentation für PropComparator für eine kurze Übersicht über die Operator-Definition auf ORM-Ebene.

Siehe auch

PropComparator

Comparator

QueryableAttribute.info

Klassensignatur

class sqlalchemy.orm.RelationshipProperty.Comparator (sqlalchemy.util.langhelpers.MemoizedSlots, sqlalchemy.orm.PropComparator)

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

Implementiert den == Operator.

In einem Many-to-One-Kontext, wie z. B.

MyClass.some_prop == <some object>

wird typischerweise eine Klausel wie diese erzeugt:

mytable.related_id == <some id>

wobei <some id> der Primärschlüssel des gegebenen Objekts ist.

Der Operator == bietet teilweise Funktionalität für Nicht-Many-to-One-Vergleiche.

Vergleiche mit Sammlungen werden nicht unterstützt. Verwenden Sie Comparator.contains().
Verglichen mit einer skalaren One-to-Many-Beziehung wird eine Klausel erzeugt, die die Zielspalten in der übergeordneten Entität mit dem gegebenen Ziel vergleicht.
Verglichen mit einer skalaren Many-to-Many-Beziehung wird auch ein Alias der Assoziationstabelle gerendert, der einen natürlichen Join bildet, der Teil des Hauptteils der Abfrage ist. Dies funktioniert nicht für Abfragen, die über einfache AND-Konjunktionen von Vergleichen hinausgehen, wie z. B. solche, die OR verwenden. Verwenden Sie explizite Joins, Outer Joins oder Comparator.has() für umfassendere skalare Mitgliedschaftstests, die keine Many-to-One-Beziehungen sind.
Vergleiche mit None in einem One-to-Many- oder Many-to-Many-Kontext erzeugen eine NOT EXISTS-Klausel.

method sqlalchemy.orm.RelationshipProperty.Comparator.__init__(prop: RelationshipProperty[_PT], parentmapper: _InternalEntityType[Any], adapt_to_entity: AliasedInsp[Any] | None = None, of_type: _EntityType[_PT] | None = None, extra_criteria: Tuple[ColumnElement[bool], ...] = ())¶: Die Konstruktion von Comparator ist intern für die Attributmechanismen des ORM.

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

Implementiert den Operator !=.

In einem Many-to-One-Kontext, wie z. B.

MyClass.some_prop != <some object>

Dies erzeugt typischerweise eine Klausel wie diese:

mytable.related_id != <some id>

wobei <some id> der Primärschlüssel des gegebenen Objekts ist.

Der Operator != bietet teilweise Funktionalität für Nicht-Many-to-One-Vergleiche.

Vergleiche mit Sammlungen werden nicht unterstützt. Verwenden Sie Comparator.contains() in Verbindung mit not_().
Verglichen mit einer skalaren One-to-Many-Beziehung wird eine Klausel erzeugt, die die Zielspalten in der übergeordneten Entität mit dem gegebenen Ziel vergleicht.
Verglichen mit einer skalaren Many-to-Many-Beziehung wird auch ein Alias der Assoziationstabelle gerendert, der einen natürlichen Join bildet, der Teil des Hauptteils der Abfrage ist. Dies funktioniert nicht für Abfragen, die über einfache AND-Konjunktionen von Vergleichen hinausgehen, wie z. B. solche, die OR verwenden. Verwenden Sie explizite Joins, Outer Joins oder Comparator.has() in Verbindung mit not_() für umfassendere skalare Mitgliedschaftstests, die keine Many-to-One-Beziehungen sind.
Vergleiche mit None in einem One-to-Many- oder Many-to-Many-Kontext erzeugen eine EXISTS-Klausel.

method sqlalchemy.orm.RelationshipProperty.Comparator.adapt_to_entity(adapt_to_entity: AliasedInsp[Any]) → RelationshipProperty.Comparator[Any]¶: Gibt eine Kopie dieses PropComparators zurück, die die angegebene AliasedInsp verwendet, um entsprechende Ausdrücke zu erzeugen.

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

Fügt AND-Kriterien hinzu.

Siehe PropComparator.and_() für ein Beispiel.

Neu in Version 1.4.

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

Erzeugt einen Ausdruck, der eine Sammlung anhand eines bestimmten Kriteriums unter Verwendung von EXISTS prüft.

Ein Ausdruck wie

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

ergibt eine Abfrage wie

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

Da Comparator.any() eine korrelierte Unterabfrage verwendet, ist seine Leistung im Vergleich zur Verwendung eines Joins nicht annähernd so gut, wenn gegen große Zieltabellen geprüft wird.

Comparator.any() ist besonders nützlich für das Testen auf leere Sammlungen

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

wird erzeugen

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

Comparator.any() ist nur für Sammlungen gültig, d.h. für ein relationship(), das uselist=True hat. Für skalare Referenzen verwenden Sie Comparator.has().

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

Gibt einen einfachen Ausdruck zurück, der eine Sammlung auf die Anwesenheit eines bestimmten Elements prüft.

Comparator.contains() ist nur für Sammlungen gültig, d.h. für ein relationship(), das Eins-zu-Viele oder Viele-zu-Viele mit uselist=True implementiert.

Bei Verwendung in einem einfachen Eins-zu-Viele-Kontext, ein Ausdruck wie

MyClass.contains(other)

Erzeugt eine Klausel wie

mytable.id == <some id>

Wobei <some id> der Wert des Fremdschlüsselattributs auf other ist, das auf den Primärschlüssel seines Elternobjekts verweist. Daraus folgt, dass Comparator.contains() bei der Verwendung mit einfachen Eins-zu-Viele-Operationen sehr nützlich ist.

Bei Viele-zu-Viele-Operationen hat das Verhalten von Comparator.contains() mehr Vorbehalte. Die Assoziationstabelle wird in der Anweisung gerendert, was einen "impliziten" Join erzeugt, d.h. mehrere Tabellen in der FROM-Klausel einschließt, die in der WHERE-Klausel gleichgesetzt werden

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

Erzeugt eine Abfrage wie

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>

Wobei <some id> der Primärschlüssel von other wäre. Aus dem Vorstehenden ist klar ersichtlich, dass Comparator.contains() **nicht** mit Viele-zu-Viele-Sammlungen funktioniert, wenn es in Abfragen verwendet wird, die über einfache UND-Verknüpfungen hinausgehen, wie z.B. mehrere Comparator.contains()-Ausdrücke, die durch ODER verbunden sind. In solchen Fällen müssen stattdessen Unterabfragen oder explizite "Outer Joins" verwendet werden. Siehe Comparator.any() für eine weniger performante Alternative mit EXISTS, oder beziehen Sie sich auf Query.outerjoin() sowie Joins für weitere Details zur Konstruktion von Outer Joins.

kwargs können von diesem Operator ignoriert werden, sind aber für die API-Konformität erforderlich.

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

Die Zielentität, auf die sich dieser Comparator bezieht.

Dies ist entweder ein Mapper- oder ein AliasedInsp-Objekt.

Dies ist die "Ziel-" oder "Remote"-Seite des relationship().

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

Erzeugt einen Ausdruck, der eine skalare Referenz gegen ein bestimmtes Kriterium prüft, unter Verwendung von EXISTS.

Ein Ausdruck wie

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

ergibt eine Abfrage wie

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

Da Comparator.has() eine korrelierte Unterabfrage verwendet, ist seine Leistung im Vergleich zur Verwendung eines Joins nicht annähernd so gut, wenn gegen große Zieltabellen geprüft wird.

Comparator.has() ist nur für skalare Referenzen gültig, d.h. für ein relationship(), das uselist=False hat. Für Sammlungsreferenzen verwenden Sie Comparator.any().

Methode sqlalchemy.orm.RelationshipProperty.Comparator.in_(other: Any) → NoReturn¶: Erzeugt eine IN-Klausel – dies wird derzeit nicht für relationship()-basierte Attribute implementiert.

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

Der Ziel-Mapper, auf den sich dieser Comparator bezieht.

Dies ist die "Ziel-" oder "Remote"-Seite des relationship().

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

Definiert dieses Objekt in Bezug auf eine polymorphe Unterklasse neu.

Siehe PropComparator.of_type() für ein Beispiel.

Attribut sqlalchemy.orm.RelationshipProperty.cascade¶: Gibt die aktuelle Cascade-Einstellung für diese RelationshipProperty zurück.

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

Iteriert durch Instanzen, die mit der gegebenen Instanz für einen bestimmten „Cascade“ verknüpft sind, beginnend mit dieser MapperProperty.

Gibt einen Iterator von Tupeln (Instanz, Mapper, Zustand) zurück.

Beachten Sie, dass zuerst die „cascade“-Sammlung auf dieser MapperProperty für den gegebenen Typ überprüft wird, bevor cascade_iterator aufgerufen wird.

Diese Methode gilt typischerweise nur für Relationship.

Methode sqlalchemy.orm.RelationshipProperty.declarative_scan(decl_scan: _ClassScanMapperConfig, registry: _RegistryType, cls: Type[Any], originating_module: str | None, key: str, mapped_container: Type[Mapped[Any]] | None, annotation: _AnnotationScanType | None, extracted_mapped_annotation: _AnnotationScanType | None, is_dataclass_field: bool) → None¶: Führt eine klassenspezifische Initialisierung zum frühen Zeitpunkt des deklarativen Scannens durch.

Neu in Version 2.0.

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

Führt subklassenspezifische Initialisierungsschritte nach der Mapper-Erstellung durch.

Dies ist eine Vorlagenmethode, die von der init()-Methode des MapperProperty-Objekts aufgerufen wird.

Attribut sqlalchemy.orm.RelationshipProperty.entity¶: Gibt die zugeordnete Zielentität zurück, die eine Inspektion der Klasse oder der aliased Klasse ist, auf die sich diese RelationshipProperty bezieht.

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

Hook, der vom Mapper aufgerufen wird, um die Instrumentierung des Klassenattributs, das von dieser MapperProperty verwaltet wird, zu initiieren.

Die MapperProperty ruft hier typischerweise das attributes-Modul auf, um ein InstrumentedAttribute einzurichten.

Dieser Schritt ist der erste von zwei Schritten zur Einrichtung eines InstrumentedAttribute und wird früh im Mapper-Einrichtungsprozess aufgerufen.

Der zweite Schritt ist typischerweise der Schritt init_class_attribute, der von StrategizedProperty über den post_instrument_class()-Hook aufgerufen wird. Dieser Schritt weist dem InstrumentedAttribute (insbesondere der "impl") zusätzlichen Zustand zu, der ermittelt wurde, nachdem die MapperProperty bestimmt hat, welche Art von Persistenzverwaltung sie durchführen muss (z. B. Skalar, Objekt, Sammlung usw.).

Attribut sqlalchemy.orm.RelationshipProperty.mapper¶: Gibt den Ziel-Mapper für diese RelationshipProperty zurück.

Methode 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¶: Führt das von dieser MapperProperty dargestellte Attribut von der Quelle zum Zielobjekt zusammen.

Klasse sqlalchemy.orm.SQLORMExpression¶

Ein Typ, der verwendet werden kann, um jedes ORM-Attribut oder -Objekt anzugeben, das an seiner Stelle fungiert, im Kontext der SQL-Ausdruckserstellung.

SQLORMExpression erweitert die Core-Klasse SQLColumnExpression um zusätzliche ORM-spezifische SQL-Methoden wie PropComparator.of_type() und ist Teil der Basen für InstrumentedAttribute. Sie kann in der PEP 484-Typisierung verwendet werden, um Argumente oder Rückgabewerte zu kennzeichnen, die sich wie ORM-Level-Attributausdrücke verhalten sollen.

Neu ab Version 2.0.0b4.

Klassensignatur

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

Klasse sqlalchemy.orm.Synonym¶

Deklarationsfront-End für die Klasse SynonymProperty.

Der öffentliche Konstruktor ist die Funktion synonym().

Geändert in Version 2.0: Synonym als Declarative-kompatible Unterklasse für SynonymProperty hinzugefügt

Siehe auch

Synonyme - Übersicht über Synonyme

Klassensignatur

class sqlalchemy.orm.Synonym (sqlalchemy.orm.descriptor_props.SynonymProperty, sqlalchemy.orm.base._DeclarativeMapped)

Klasse sqlalchemy.orm.SynonymProperty¶

Bezeichnet einen Attributnamen als Synonym für eine zugeordnete Eigenschaft, sodass das Attribut den Wert und das Ausdrucksverhalten eines anderen Attributs widerspiegelt.

Synonym wird mit der Funktion synonym() konstruiert.

Siehe auch

Synonyme - Übersicht über Synonyme

Mitglieder

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

Klassensignatur

class sqlalchemy.orm.SynonymProperty (sqlalchemy.orm.descriptor_props.DescriptorProperty)

Attribut sqlalchemy.orm.SynonymProperty.doc: str | None¶: geerbt vom DescriptorProperty.doc Attribut von DescriptorProperty

optionale Dokumentationszeichenkette

Attribut sqlalchemy.orm.SynonymProperty.info: _InfoType¶

geerbt vom MapperProperty.info Attribut von MapperProperty

Info-Dictionary, das mit dem Objekt verbunden ist und es dem Benutzer ermöglicht, benutzerdefinierte Daten mit diesem InspectionAttr zu verknüpfen.

Das Dictionary wird beim ersten Zugriff generiert. Alternativ kann es als Konstruktorargument an die Funktionen column_property(), relationship() oder composite() übergeben werden.

Siehe auch

Mapper.all_orm_descriptors

Attribut sqlalchemy.orm.SynonymProperty.key: str¶: geerbt vom MapperProperty.key Attribut von MapperProperty

Name des Klassenattributs

Attribut sqlalchemy.orm.SynonymProperty.parent: Mapper[Any]¶: geerbt vom MapperProperty.parent Attribut von MapperProperty

der Mapper, der diese Eigenschaft verwaltet.

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

Setzt den übergeordneten Mapper, der auf diese MapperProperty verweist.

Diese Methode wird von einigen Unterklassen überschrieben, um zusätzliche Einrichtungen durchzuführen, wenn der Mapper zum ersten Mal bekannt ist.

Attribut sqlalchemy.orm.SynonymProperty.uses_objects¶

Klasse sqlalchemy.orm.QueryContext¶

Klasse default_load_options¶: Klassensignatur

class sqlalchemy.orm.QueryContext.default_load_options (sqlalchemy.sql.expression.Options)

Klasse sqlalchemy.orm.QueryableAttribute¶

Basisklasse für Deskriptor-Objekte, die Attributereignisse im Namen eines MapperProperty-Objekts abfangen. Die tatsächliche MapperProperty ist über das Attribut QueryableAttribute.property zugänglich.

Siehe auch

InstrumentedAttribute

MapperProperty

Mapper.attrs

Mitglieder

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

Klassensignatur

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)

methode sqlalchemy.orm.QueryableAttribute.adapt_to_entity(adapt_to_entity: AliasedInsp[Any]) → Self¶: Gibt eine Kopie dieses PropComparators zurück, die die angegebene AliasedInsp verwendet, um entsprechende Ausdrücke zu erzeugen.

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

Fügt zusätzliche Kriterien zur ON-Klausel hinzu, die durch dieses Beziehungsattribut repräsentiert wird.

Z. B.

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

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

Neu in Version 1.4.

Siehe auch

Kombinieren von Beziehungen mit benutzerdefinierten ON-Kriterien

Kriterien zu Loader-Optionen hinzufügen

with_loader_criteria()

attribut sqlalchemy.orm.QueryableAttribute.expression: ColumnElement[_T_co]¶

Das SQL-Ausdrucksobjekt, das von diesem QueryableAttribute dargestellt wird.

Dies ist normalerweise eine Instanz einer Unterklasse von ColumnElement, die einen Spaltenausdruck darstellt.

attribut sqlalchemy.orm.QueryableAttribute.info¶

Gibt das 'info'-Wörterbuch für das zugrunde liegende SQL-Element zurück.

Das Verhalten ist wie folgt:

Wenn das Attribut eine spalten-zugeordnete Eigenschaft ist, d.h. ColumnProperty, die direkt einem schemaweiten Column-Objekt zugeordnet ist, gibt dieses Attribut das SchemaItem.info-Wörterbuch zurück, das dem Kern-Level Column-Objekt zugeordnet ist.
Wenn das Attribut eine ColumnProperty ist, aber einer anderen Art von SQL-Ausdruck als einer Column zugeordnet ist, bezieht sich das Attribut auf das MapperProperty.info-Wörterbuch, das direkt der ColumnProperty zugeordnet ist, vorausgesetzt, dass der SQL-Ausdruck selbst kein eigenes `.info`-Attribut hat (was der Fall sein sollte, es sei denn, ein benutzerdefinierter SQL-Konstrukt hat eines definiert).
Wenn sich das Attribut auf eine andere Art von MapperProperty bezieht, einschließlich Relationship, bezieht sich das Attribut auf das MapperProperty.info-Wörterbuch, das dieser MapperProperty zugeordnet ist.
Um bedingungslos auf das MapperProperty.info-Wörterbuch zuzugreifen, auch für eine ColumnProperty, die direkt einer Column zugeordnet ist, kann auf das Attribut über das Attribut QueryableAttribute.property zugegriffen werden, z.B. MyClass.someattribute.property.info.

Siehe auch