Association Proxy

associationproxy wird verwendet, um eine Lese-/Schreibansicht eines Zielattributs über eine Beziehung zu erstellen. Es verbirgt im Wesentlichen die Verwendung eines "mittleren" Attributs zwischen zwei Endpunkten und kann verwendet werden, um Felder aus einer Sammlung von verwandten Objekten oder einem skalaren Beziehung auszuwählen. oder um die Wortkargheit der Verwendung des Association-Objekt-Musters zu reduzieren. Kreativ angewendet, ermöglicht der Association-Proxy den Aufbau komplexer Sammlungen und Dictionary-Ansichten praktisch jeder Geometrie, die mithilfe von Standard- und transparent konfigurierten relationalen Mustern in der Datenbank gespeichert wird.

Vereinfachung von Skalaren Sammlungen

Betrachten Sie eine Many-to-Many-Zuordnung zwischen zwei Klassen, User und Keyword. Jeder User kann eine beliebige Anzahl von Keyword -Objekten haben und umgekehrt (das Many-to-Many-Muster wird unter Many To Many beschrieben). Das obige Beispiel illustriert dieses Muster auf dieselbe Weise, mit Ausnahme eines zusätzlichen Attributs, das der User -Klasse namens User.keywords hinzugefügt wurde.

from __future__ import annotations

from typing import Final
from typing import List

from sqlalchemy import Column
from sqlalchemy import ForeignKey
from sqlalchemy import Integer
from sqlalchemy import String
from sqlalchemy import Table
from sqlalchemy.orm import DeclarativeBase
from sqlalchemy.orm import Mapped
from sqlalchemy.orm import mapped_column
from sqlalchemy.orm import relationship
from sqlalchemy.ext.associationproxy import association_proxy
from sqlalchemy.ext.associationproxy import AssociationProxy


class Base(DeclarativeBase):
    pass


class User(Base):
    __tablename__ = "user"
    id: Mapped[int] = mapped_column(primary_key=True)
    name: Mapped[str] = mapped_column(String(64))
    kw: Mapped[List[Keyword]] = relationship(secondary=lambda: user_keyword_table)

    def __init__(self, name: str):
        self.name = name

    # proxy the 'keyword' attribute from the 'kw' relationship
    keywords: AssociationProxy[List[str]] = association_proxy("kw", "keyword")


class Keyword(Base):
    __tablename__ = "keyword"
    id: Mapped[int] = mapped_column(primary_key=True)
    keyword: Mapped[str] = mapped_column(String(64))

    def __init__(self, keyword: str):
        self.keyword = keyword


user_keyword_table: Final[Table] = Table(
    "user_keyword",
    Base.metadata,
    Column("user_id", Integer, ForeignKey("user.id"), primary_key=True),
    Column("keyword_id", Integer, ForeignKey("keyword.id"), primary_key=True),
)

Im obigen Beispiel wird association_proxy() auf die User -Klasse angewendet, um eine "Ansicht" der kw -Beziehung zu erzeugen, die den Zeichenkettenwert von .keyword, der jedem Keyword -Objekt zugeordnet ist, offenlegt. Außerdem werden neue Keyword -Objekte transparent erstellt, wenn Zeichenketten zur Sammlung hinzugefügt werden.

>>> user = User("jek")
>>> user.keywords.append("cheese-inspector")
>>> user.keywords.append("snack-ninja")
>>> print(user.keywords)
['cheese-inspector', 'snack-ninja']

Um die Mechanik zu verstehen, überprüfen Sie zuerst das Verhalten von User und Keyword, ohne den .keywords Association-Proxy zu verwenden. Normalerweise erfordert das Lesen und Bearbeiten der Sammlung von "Schlüsselwort"-Zeichenketten, die mit User verbunden sind, eine Durchquerung von jedem Sammlungselement zum Attribut .keyword, was umständlich sein kann. Das folgende Beispiel illustriert dieselbe Reihe von Operationen ohne die Verwendung des Association-Proxys.

>>> # identical operations without using the association proxy
>>> user = User("jek")
>>> user.kw.append(Keyword("cheese-inspector"))
>>> user.kw.append(Keyword("snack-ninja"))
>>> print([keyword.keyword for keyword in user.kw])
['cheese-inspector', 'snack-ninja']

Das von der Funktion association_proxy() erzeugte AssociationProxy -Objekt ist eine Instanz eines Python-Deskriptors und wird in keiner Weise von dem Mapper als "gemappt" betrachtet. Daher wird er immer innerhalb der Klassendefinition der gemappten Klasse inline angegeben, unabhängig davon, ob Deklarative oder Imperative Mappings verwendet werden.

Der Proxy funktioniert, indem er auf das zugrunde liegende gemappte Attribut oder die Sammlung als Reaktion auf Operationen zugreift, und Änderungen, die über den Proxy vorgenommen werden, sind sofort im gemappten Attribut sichtbar, ebenso wie umgekehrt. Das zugrunde liegende Attribut bleibt vollständig zugänglich.

Bei der ersten Verwendung führt der Association-Proxy Introspektionsoperationen an der Zielsammlung durch, damit sein Verhalten korrekt übereinstimmt. Details wie die Tatsache, ob das lokal proxy-gebundene Attribut eine Sammlung (wie üblich) oder eine skalare Referenz ist, sowie ob die Sammlung wie ein Set, eine Liste oder ein Dictionary funktioniert, werden berücksichtigt, sodass der Proxy sich genauso verhalten sollte wie die zugrunde liegende Sammlung oder das Attribut.

Erstellung neuer Werte

Wenn ein Listen- append() -Ereignis (oder ein Set- add() -, Dictionary- __setitem__() - oder skalare Zuweisungsereignis) vom Association-Proxy abgefangen wird, instanziiert er ein neues Exemplar des "Zwischenobjekts" mit seinem Konstruktor und übergibt den gegebenen Wert als einziges Argument. In unserem obigen Beispiel wird eine Operation wie

user.keywords.append("cheese-inspector")

wird vom Association-Proxy in die Operation übersetzt

user.kw.append(Keyword("cheese-inspector"))

Das Beispiel funktioniert hier, weil wir den Konstruktor für Keyword so konzipiert haben, dass er ein einzelnes positionsgebundenes Argument, keyword, akzeptiert. Für Fälle, in denen ein Konstruktor mit einem Argument nicht machbar ist, kann das Erstellungsverhalten des Association-Proxys mithilfe des Arguments association_proxy.creator angepasst werden, das auf einen aufrufbaren Wert (d. h. eine Python-Funktion) verweist, der eine neue Objektinstanz unter Angabe des einzelnen Arguments erzeugt. Unten illustrieren wir dies typischerweise mit einem Lambda.

class User(Base):
    ...

    # use Keyword(keyword=kw) on append() events
    keywords: AssociationProxy[List[str]] = association_proxy(
        "kw", "keyword", creator=lambda kw: Keyword(keyword=kw)
    )

Die creator -Funktion akzeptiert ein einzelnes Argument im Falle einer Listen- oder Set-basierten Sammlung oder eines skalaren Attributs. Im Falle einer Dictionary-basierten Sammlung akzeptiert sie zwei Argumente, "key" und "value". Ein Beispiel hierfür finden Sie unten unter Proxy auf Dictionary-basierte Sammlungen.

Vereinfachung von Association-Objekten

Das "Association-Objekt"-Muster ist eine erweiterte Form einer Many-to-Many-Beziehung und wird unter Association Object beschrieben. Association-Proxies sind nützlich, um "Association-Objekte" während des normalen Gebrauchs aus dem Weg zu halten.

Angenommen, unsere user_keyword -Tabelle hätte zusätzliche Spalten, die wir explizit zuordnen möchten, aber in den meisten Fällen benötigen wir keinen direkten Zugriff auf diese Attribute. Unten illustrieren wir eine neue Zuordnung, die die Klasse UserKeywordAssociation einführt, die der zuvor gezeigten user_keyword -Tabelle zugeordnet ist. Diese Klasse fügt eine zusätzliche Spalte special_key hinzu, ein Wert, auf den wir gelegentlich zugreifen möchten, aber nicht im üblichen Fall. Wir erstellen einen Association-Proxy für die User -Klasse namens keywords, der die Lücke von der user_keyword_associations -Sammlung von User zum Attribut .keyword, das auf jedem UserKeywordAssociation vorhanden ist, überbrückt.

from __future__ import annotations

from typing import List
from typing import Optional

from sqlalchemy import ForeignKey
from sqlalchemy import String
from sqlalchemy.ext.associationproxy import association_proxy
from sqlalchemy.ext.associationproxy import AssociationProxy
from sqlalchemy.orm import DeclarativeBase
from sqlalchemy.orm import Mapped
from sqlalchemy.orm import mapped_column
from sqlalchemy.orm import relationship


class Base(DeclarativeBase):
    pass


class User(Base):
    __tablename__ = "user"

    id: Mapped[int] = mapped_column(primary_key=True)
    name: Mapped[str] = mapped_column(String(64))

    user_keyword_associations: Mapped[List[UserKeywordAssociation]] = relationship(
        back_populates="user",
        cascade="all, delete-orphan",
    )

    # association proxy of "user_keyword_associations" collection
    # to "keyword" attribute
    keywords: AssociationProxy[List[Keyword]] = association_proxy(
        "user_keyword_associations",
        "keyword",
        creator=lambda keyword_obj: UserKeywordAssociation(keyword=keyword_obj),
    )

    def __init__(self, name: str):
        self.name = name


class UserKeywordAssociation(Base):
    __tablename__ = "user_keyword"
    user_id: Mapped[int] = mapped_column(ForeignKey("user.id"), primary_key=True)
    keyword_id: Mapped[int] = mapped_column(ForeignKey("keyword.id"), primary_key=True)
    special_key: Mapped[Optional[str]] = mapped_column(String(50))

    user: Mapped[User] = relationship(back_populates="user_keyword_associations")

    keyword: Mapped[Keyword] = relationship()


class Keyword(Base):
    __tablename__ = "keyword"
    id: Mapped[int] = mapped_column(primary_key=True)
    keyword: Mapped[str] = mapped_column("keyword", String(64))

    def __init__(self, keyword: str):
        self.keyword = keyword

    def __repr__(self) -> str:
        return f"Keyword({self.keyword!r})"

Mit der obigen Konfiguration können wir auf die .keywords -Sammlung jedes User -Objekts zugreifen, wobei jedes eine Sammlung von Keyword -Objekten offenbart, die aus den zugrunde liegenden UserKeywordAssociation -Elementen stammen.

>>> user = User("log")
>>> for kw in (Keyword("new_from_blammo"), Keyword("its_big")):
...     user.keywords.append(kw)
>>> print(user.keywords)
[Keyword('new_from_blammo'), Keyword('its_big')]

Dieses Beispiel steht im Gegensatz zu dem zuvor unter Vereinfachung von Skalaren Sammlungen gezeigten Beispiel, bei dem der Association-Proxy eine Sammlung von Zeichenketten und nicht eine Sammlung von zusammengesetzten Objekten offenbart. In diesem Fall ist jede .keywords.append() -Operation äquivalent zu

>>> user.user_keyword_associations.append(
...     UserKeywordAssociation(keyword=Keyword("its_heavy"))
... )

Das UserKeywordAssociation -Objekt hat zwei Attribute, die beide im Geltungsbereich der append() -Operation des Association-Proxys befüllt werden; .keyword, das sich auf das Keyword -Objekt bezieht, und .user, das sich auf das User -Objekt bezieht. Das Attribut .keyword wird zuerst befüllt, da der Association-Proxy ein neues UserKeywordAssociation -Objekt als Reaktion auf die .append() -Operation generiert und die gegebene Keyword -Instanz dem Attribut .keyword zuweist. Dann, da das UserKeywordAssociation -Objekt der User.user_keyword_associations -Sammlung hinzugefügt wird, wird das Attribut UserKeywordAssociation.user, das als back_populates für User.user_keyword_associations konfiguriert ist, bei der gegebenen UserKeywordAssociation -Instanz initialisiert, um auf das übergeordnete User -Objekt zu verweisen, das die Append-Operation empfängt. Das Argument special_key oben bleibt auf seinem Standardwert von None.

Für die Fälle, in denen wir möchten, dass special_key einen Wert hat, erstellen wir das UserKeywordAssociation -Objekt explizit. Unten weisen wir alle drei Attribute zu, wobei die Zuweisung von .user während der Konstruktion die Auswirkung hat, dass das neue UserKeywordAssociation der User.user_keyword_associations -Sammlung hinzugefügt wird (über die Beziehung).

>>> UserKeywordAssociation(
...     keyword=Keyword("its_wood"), user=user, special_key="my special key"
... )

Der Association-Proxy gibt uns eine Sammlung von Keyword -Objekten zurück, die durch all diese Operationen repräsentiert werden.

>>> print(user.keywords)
[Keyword('new_from_blammo'), Keyword('its_big'), Keyword('its_heavy'), Keyword('its_wood')]

Proxy auf Dictionary-basierte Sammlungen

Der Association-Proxy kann auch auf Dictionary-basierte Sammlungen angewendet werden. SQLAlchemy-Mappings verwenden üblicherweise den Sammlungstyp attribute_keyed_dict(), um Dictionary-Sammlungen zu erstellen, sowie die erweiterten Techniken, die unter Benutzerdefinierte Dictionary-basierte Sammlungen beschrieben sind.

Der Association-Proxy passt sein Verhalten an, wenn er die Verwendung einer Dictionary-basierten Sammlung erkennt. Wenn neue Werte dem Dictionary hinzugefügt werden, instanziiert der Association-Proxy das Zwischenobjekt, indem er zwei Argumente an die Erstellungsfunktion übergibt statt eines: den Schlüssel und den Wert. Wie immer ist diese Erstellungsfunktion standardmäßig der Konstruktor der Zwischenklasse und kann mit dem Argument creator angepasst werden.

Unten modifizieren wir unser UserKeywordAssociation -Beispiel so, dass die User.user_keyword_associations -Sammlung nun mithilfe eines Dictionaries zugeordnet wird, wobei das Argument UserKeywordAssociation.special_key als Schlüssel für das Dictionary verwendet wird. Wir wenden auch ein creator -Argument auf den User.keywords -Proxy an, damit diese Werte ordnungsgemäß zugewiesen werden, wenn neue Elemente zum Dictionary hinzugefügt werden.

from __future__ import annotations
from typing import Dict

from sqlalchemy import ForeignKey
from sqlalchemy import String
from sqlalchemy.ext.associationproxy import association_proxy
from sqlalchemy.ext.associationproxy import AssociationProxy
from sqlalchemy.orm import DeclarativeBase
from sqlalchemy.orm import Mapped
from sqlalchemy.orm import mapped_column
from sqlalchemy.orm import relationship
from sqlalchemy.orm.collections import attribute_keyed_dict


class Base(DeclarativeBase):
    pass


class User(Base):
    __tablename__ = "user"
    id: Mapped[int] = mapped_column(primary_key=True)
    name: Mapped[str] = mapped_column(String(64))

    # user/user_keyword_associations relationship, mapping
    # user_keyword_associations with a dictionary against "special_key" as key.
    user_keyword_associations: Mapped[Dict[str, UserKeywordAssociation]] = relationship(
        back_populates="user",
        collection_class=attribute_keyed_dict("special_key"),
        cascade="all, delete-orphan",
    )
    # proxy to 'user_keyword_associations', instantiating
    # UserKeywordAssociation assigning the new key to 'special_key',
    # values to 'keyword'.
    keywords: AssociationProxy[Dict[str, Keyword]] = association_proxy(
        "user_keyword_associations",
        "keyword",
        creator=lambda k, v: UserKeywordAssociation(special_key=k, keyword=v),
    )

    def __init__(self, name: str):
        self.name = name


class UserKeywordAssociation(Base):
    __tablename__ = "user_keyword"
    user_id: Mapped[int] = mapped_column(ForeignKey("user.id"), primary_key=True)
    keyword_id: Mapped[int] = mapped_column(ForeignKey("keyword.id"), primary_key=True)
    special_key: Mapped[str]

    user: Mapped[User] = relationship(
        back_populates="user_keyword_associations",
    )
    keyword: Mapped[Keyword] = relationship()


class Keyword(Base):
    __tablename__ = "keyword"
    id: Mapped[int] = mapped_column(primary_key=True)
    keyword: Mapped[str] = mapped_column(String(64))

    def __init__(self, keyword: str):
        self.keyword = keyword

    def __repr__(self) -> str:
        return f"Keyword({self.keyword!r})"

Wir illustrieren die .keywords -Sammlung als Dictionary, das den UserKeywordAssociation.special_key -Wert dem Keyword -Objekt zuordnet.

>>> user = User("log")

>>> user.keywords["sk1"] = Keyword("kw1")
>>> user.keywords["sk2"] = Keyword("kw2")

>>> print(user.keywords)
{'sk1': Keyword('kw1'), 'sk2': Keyword('kw2')}

Zusammengesetzte Association-Proxies

Angesichts unserer früheren Beispiele für das Proxying von Beziehungen zu skalaren Attributen, über Association-Objekte und für Dictionaries können wir alle drei Techniken kombinieren, um User ein keywords -Dictionary zur Verfügung zu stellen, das streng mit dem Zeichenkettenwert von special_key zugeordnet zu der Zeichenkette keyword umgeht. Sowohl die Klassen UserKeywordAssociation als auch Keyword sind vollständig verborgen. Dies wird erreicht, indem ein Association-Proxy auf User aufgebaut wird, der auf einen Association-Proxy auf UserKeywordAssociation verweist.

from __future__ import annotations

from sqlalchemy import ForeignKey
from sqlalchemy import String
from sqlalchemy.ext.associationproxy import association_proxy
from sqlalchemy.ext.associationproxy import AssociationProxy
from sqlalchemy.orm import DeclarativeBase
from sqlalchemy.orm import Mapped
from sqlalchemy.orm import mapped_column
from sqlalchemy.orm import relationship
from sqlalchemy.orm.collections import attribute_keyed_dict


class Base(DeclarativeBase):
    pass


class User(Base):
    __tablename__ = "user"
    id: Mapped[int] = mapped_column(primary_key=True)
    name: Mapped[str] = mapped_column(String(64))

    user_keyword_associations: Mapped[Dict[str, UserKeywordAssociation]] = relationship(
        back_populates="user",
        collection_class=attribute_keyed_dict("special_key"),
        cascade="all, delete-orphan",
    )
    # the same 'user_keyword_associations'->'keyword' proxy as in
    # the basic dictionary example.
    keywords: AssociationProxy[Dict[str, str]] = association_proxy(
        "user_keyword_associations",
        "keyword",
        creator=lambda k, v: UserKeywordAssociation(special_key=k, keyword=v),
    )

    def __init__(self, name: str):
        self.name = name


class UserKeywordAssociation(Base):
    __tablename__ = "user_keyword"
    user_id: Mapped[int] = mapped_column(ForeignKey("user.id"), primary_key=True)
    keyword_id: Mapped[int] = mapped_column(ForeignKey("keyword.id"), primary_key=True)
    special_key: Mapped[str] = mapped_column(String(64))
    user: Mapped[User] = relationship(
        back_populates="user_keyword_associations",
    )

    # the relationship to Keyword is now called
    # 'kw'
    kw: Mapped[Keyword] = relationship()

    # 'keyword' is changed to be a proxy to the
    # 'keyword' attribute of 'Keyword'
    keyword: AssociationProxy[Dict[str, str]] = association_proxy("kw", "keyword")


class Keyword(Base):
    __tablename__ = "keyword"
    id: Mapped[int] = mapped_column(primary_key=True)
    keyword: Mapped[str] = mapped_column(String(64))

    def __init__(self, keyword: str):
        self.keyword = keyword

User.keywords ist jetzt ein Dictionary von Zeichenkette zu Zeichenkette, wobei UserKeywordAssociation - und Keyword -Objekte transparent für uns mithilfe des Association-Proxys erstellt und entfernt werden. Im folgenden Beispiel illustrieren wir die Verwendung des Zuweisungsoperators, der ebenfalls vom Association-Proxy ordnungsgemäß behandelt wird, um einem Sammlungswert auf einmal ein Dictionary zuzuweisen.

>>> user = User("log")
>>> user.keywords = {"sk1": "kw1", "sk2": "kw2"}
>>> print(user.keywords)
{'sk1': 'kw1', 'sk2': 'kw2'}

>>> user.keywords["sk3"] = "kw3"
>>> del user.keywords["sk2"]
>>> print(user.keywords)
{'sk1': 'kw1', 'sk3': 'kw3'}

>>> # illustrate un-proxied usage
... print(user.user_keyword_associations["sk3"].kw)
<__main__.Keyword object at 0x12ceb90>

Ein Vorbehalt bei unserem obigen Beispiel ist, dass, da Keyword -Objekte für jede Dictionary-Set-Operation erstellt werden, das Beispiel die Eindeutigkeit der Keyword -Objekte anhand ihres Zeichenkettennamens nicht beibehält, was eine typische Anforderung für ein Tagging-Szenario wie dieses ist. Für diesen Anwendungsfall wird das Rezept UniqueObject oder eine vergleichbare Erstellungsstrategie empfohlen, die eine "erst suchen, dann erstellen"-Strategie auf den Konstruktor der Keyword -Klasse anwendet, sodass ein bereits vorhandenes Keyword zurückgegeben wird, wenn der gegebene Name bereits vorhanden ist.

Abfragen mit Association-Proxies

Der AssociationProxy bietet einfache SQL-Konstruktionsfähigkeiten, die auf Klassenebene ähnlich wie andere ORM-gemappte Attribute funktionieren und rudimentäre Filterunterstützung bieten, hauptsächlich basierend auf dem SQL-Schlüsselwort EXISTS.

Hinweis

Der Hauptzweck der Association-Proxy-Erweiterung ist es, verbesserte Persistenz- und Objektzugriffsmuster mit bereits geladenen gemappten Objektinstanzen zu ermöglichen. Die klassenbezogene Abfragefunktion ist von begrenztem Nutzen und wird nicht den Bedarf ersetzen, auf die zugrunde liegenden Attribute beim Konstruieren von SQL-Abfragen mit JOINs, eager loading-Optionen usw. zu verweisen.

Für diesen Abschnitt nehmen wir eine Klasse mit sowohl einem Association-Proxy an, der auf eine Spalte verweist, als auch einem Association-Proxy, der auf ein verwandtes Objekt verweist, wie in der folgenden Beispielzuordnung.

from __future__ import annotations
from sqlalchemy import Column, ForeignKey, Integer, String
from sqlalchemy.ext.associationproxy import association_proxy, AssociationProxy
from sqlalchemy.orm import DeclarativeBase, relationship
from sqlalchemy.orm.collections import attribute_keyed_dict
from sqlalchemy.orm.collections import Mapped


class Base(DeclarativeBase):
    pass


class User(Base):
    __tablename__ = "user"
    id: Mapped[int] = mapped_column(primary_key=True)
    name: Mapped[str] = mapped_column(String(64))

    user_keyword_associations: Mapped[UserKeywordAssociation] = relationship(
        cascade="all, delete-orphan",
    )

    # object-targeted association proxy
    keywords: AssociationProxy[List[Keyword]] = association_proxy(
        "user_keyword_associations",
        "keyword",
    )

    # column-targeted association proxy
    special_keys: AssociationProxy[List[str]] = association_proxy(
        "user_keyword_associations", "special_key"
    )


class UserKeywordAssociation(Base):
    __tablename__ = "user_keyword"
    user_id: Mapped[int] = mapped_column(ForeignKey("user.id"), primary_key=True)
    keyword_id: Mapped[int] = mapped_column(ForeignKey("keyword.id"), primary_key=True)
    special_key: Mapped[str] = mapped_column(String(64))
    keyword: Mapped[Keyword] = relationship()


class Keyword(Base):
    __tablename__ = "keyword"
    id: Mapped[int] = mapped_column(primary_key=True)
    keyword: Mapped[str] = mapped_column(String(64))

Die generierte SQL nimmt die Form einer korrelierten Unterabfrage gegen den EXISTS-SQL-Operator an, sodass sie in einer WHERE-Klausel verwendet werden kann, ohne dass zusätzliche Modifikationen an der umgebenden Abfrage erforderlich sind. Wenn das unmittelbare Ziel eines Association-Proxys ein **gemappter Spaltenausdruck** ist, können Standard-Spaltenoperatoren verwendet werden, die in die Unterabfrage eingebettet werden. Zum Beispiel ein einfacher Gleichheitsoperator

>>> print(session.scalars(select(User).where(User.special_keys == "jek")))
SELECT "user".id AS user_id, "user".name AS user_name
FROM "user"
WHERE EXISTS (SELECT 1
FROM user_keyword
WHERE "user".id = user_keyword.user_id AND user_keyword.special_key = :special_key_1)

ein LIKE-Operator

>>> print(session.scalars(select(User).where(User.special_keys.like("%jek"))))
SELECT "user".id AS user_id, "user".name AS user_name
FROM "user"
WHERE EXISTS (SELECT 1
FROM user_keyword
WHERE "user".id = user_keyword.user_id AND user_keyword.special_key LIKE :special_key_1)

Für Association-Proxies, bei denen das unmittelbare Ziel ein **verwandtes Objekt oder eine Sammlung, oder ein anderer Association-Proxy oder ein Attribut des verwandten Objekts** ist, können stattdessen beziehungsorientierte Operatoren verwendet werden, wie z. B. PropComparator.has() und PropComparator.any(). Das Attribut User.keywords ist tatsächlich zwei Association-Proxies, die miteinander verbunden sind. Wenn wir diesen Proxy also zur Generierung von SQL-Phrasen verwenden, erhalten wir zwei Ebenen von EXISTS-Unterabfragen.

>>> print(session.scalars(select(User).where(User.keywords.any(Keyword.keyword == "jek"))))
SELECT "user".id AS user_id, "user".name AS user_name
FROM "user"
WHERE EXISTS (SELECT 1
FROM user_keyword
WHERE "user".id = user_keyword.user_id AND (EXISTS (SELECT 1
FROM keyword
WHERE keyword.id = user_keyword.keyword_id AND keyword.keyword = :keyword_1)))

Dies ist nicht die effizienteste Form von SQL. Daher können Association-Proxies zwar bequem zum schnellen Generieren von WHERE-Kriterien sein, aber SQL-Ergebnisse sollten inspiziert und in explizite JOIN-Kriterien "entrollt" werden, um sie optimal zu nutzen, insbesondere beim Verketten von Association-Proxies.

Geändert in Version 1.3: Association-Proxy bietet nun standardmäßige Spaltenoperatoren für ein spaltenorientiertes Ziel. Siehe AssociationProxy bietet nun standardmäßige Spaltenoperatoren für ein spaltenorientiertes Ziel.

Kaskadierendes Skalares Löschen

Neu in Version 1.3.

Gegeben eine Zuordnung als

from __future__ import annotations
from sqlalchemy import Column, ForeignKey, Integer, String
from sqlalchemy.ext.associationproxy import association_proxy, AssociationProxy
from sqlalchemy.orm import DeclarativeBase, relationship
from sqlalchemy.orm.collections import attribute_keyed_dict
from sqlalchemy.orm.collections import Mapped


class Base(DeclarativeBase):
    pass


class A(Base):
    __tablename__ = "test_a"
    id: Mapped[int] = mapped_column(primary_key=True)
    ab: Mapped[AB] = relationship(uselist=False)
    b: AssociationProxy[B] = association_proxy(
        "ab", "b", creator=lambda b: AB(b=b), cascade_scalar_deletes=True
    )


class B(Base):
    __tablename__ = "test_b"
    id: Mapped[int] = mapped_column(primary_key=True)


class AB(Base):
    __tablename__ = "test_ab"
    a_id: Mapped[int] = mapped_column(ForeignKey(A.id), primary_key=True)
    b_id: Mapped[int] = mapped_column(ForeignKey(B.id), primary_key=True)

    b: Mapped[B] = relationship()

Eine Zuweisung an A.b generiert ein AB -Objekt.

a.b = B()

Die A.b -Assoziation ist skalar und beinhaltet die Verwendung des Parameters AssociationProxy.cascade_scalar_deletes. Wenn dieser Parameter aktiviert ist, entfernt das Setzen von A.b auf None auch A.ab.

a.b = None
assert a.ab is None

Wenn AssociationProxy.cascade_scalar_deletes nicht gesetzt ist, würde das Association-Objekt a.ab oben bestehen bleiben.

Beachten Sie, dass dies nicht das Verhalten für sammlungsbasierte Association-Proxies ist; in diesem Fall wird das zwischengeschaltete Association-Objekt immer entfernt, wenn Mitglieder der proxy-gebundenen Sammlung entfernt werden. Ob die Zeile gelöscht wird oder nicht, hängt von der Kaskadeneinstellung der Beziehung ab.

Siehe auch

Kaskaden

Skalare Beziehungen

Das folgende Beispiel illustriert die Verwendung des Association-Proxys auf der "many"-Seite einer One-to-Many-Beziehung, die auf Attribute eines skalaren Objekts zugreift.

from __future__ import annotations

from typing import List

from sqlalchemy import ForeignKey
from sqlalchemy import String
from sqlalchemy.ext.associationproxy import association_proxy
from sqlalchemy.ext.associationproxy import AssociationProxy
from sqlalchemy.orm import DeclarativeBase
from sqlalchemy.orm import Mapped
from sqlalchemy.orm import mapped_column
from sqlalchemy.orm import relationship


class Base(DeclarativeBase):
    pass


class Recipe(Base):
    __tablename__ = "recipe"
    id: Mapped[int] = mapped_column(primary_key=True)
    name: Mapped[str] = mapped_column(String(64))

    steps: Mapped[List[Step]] = relationship(back_populates="recipe")
    step_descriptions: AssociationProxy[List[str]] = association_proxy(
        "steps", "description"
    )


class Step(Base):
    __tablename__ = "step"
    id: Mapped[int] = mapped_column(primary_key=True)
    description: Mapped[str]
    recipe_id: Mapped[int] = mapped_column(ForeignKey("recipe.id"))
    recipe: Mapped[Recipe] = relationship(back_populates="steps")

    recipe_name: AssociationProxy[str] = association_proxy("recipe", "name")

    def __init__(self, description: str) -> None:
        self.description = description


my_snack = Recipe(
    name="afternoon snack",
    step_descriptions=[
        "slice bread",
        "spread peanut butted",
        "eat sandwich",
    ],
)

Eine Zusammenfassung der Schritte von my_snack kann mit folgendem gedruckt werden:

>>> for i, step in enumerate(my_snack.steps, 1):
...     print(f"Step {i} of {step.recipe_name!r}: {step.description}")
Step 1 of 'afternoon snack': slice bread
Step 2 of 'afternoon snack': spread peanut butted
Step 3 of 'afternoon snack': eat sandwich

API-Dokumentation

Objektname	Beschreibung
association_proxy(target_collection, attr, *, [creator, getset_factory, proxy_factory, proxy_bulk_set, info, cascade_scalar_deletes, create_on_none_assignment, init, repr, default, default_factory, compare, kw_only, hash])	Gibt eine Python-Eigenschaft zurück, die eine Ansicht eines Zielattributs implementiert, das auf ein Attribut von Mitgliedern des Ziels verweist.
AssociationProxy	Ein Deskriptor, der eine Lese-/Schreibansicht eines Objektattributs präsentiert.
AssociationProxyExtensionType	Eine Aufzählung.
AssociationProxyInstance	Ein pro-Klasse-Objekt, das klassen- und objektspezifische Ergebnisse liefert.
ColumnAssociationProxyInstance	eine AssociationProxyInstance, die eine Datenbankspalte als Ziel hat.
ObjectAssociationProxyInstance	eine AssociationProxyInstance, die ein Objekt als Ziel hat.

funktion sqlalchemy.ext.associationproxy.association_proxy(target_collection: str, attr: str, *, creator: _CreatorProtocol | None = None, getset_factory: _GetSetFactoryProtocol | None = None, proxy_factory: _ProxyFactoryProtocol | None = None, proxy_bulk_set: _ProxyBulkSetProtocol | None = None, info: _InfoType | None = None, cascade_scalar_deletes: bool = False, create_on_none_assignment: bool = False, init: _NoArg | bool = _NoArg.NO_ARG, repr: _NoArg | bool = _NoArg.NO_ARG, default: Any | None = _NoArg.NO_ARG, default_factory: _NoArg | Callable[[], _T] = _NoArg.NO_ARG, compare: _NoArg | bool = _NoArg.NO_ARG, kw_only: _NoArg | bool = _NoArg.NO_ARG, hash: _NoArg | bool | None = _NoArg.NO_ARG) → AssociationProxy[Any]

Gibt eine Python-Eigenschaft zurück, die eine Ansicht eines Zielattributs implementiert, das auf ein Attribut von Mitgliedern des Ziels verweist.

Der zurückgegebene Wert ist eine Instanz von AssociationProxy.

Implementiert eine Python-Eigenschaft, die eine Beziehung als Sammlung einfacher Werte oder als Skalarwert darstellt. Die durchgesteuerte Eigenschaft ahmt den Sammlungstyp des Ziels (Liste, Wörterbuch oder Menge) nach, oder im Falle einer Eins-zu-Eins-Beziehung einen einfachen Skalarwert.

Parameter:

• target_collection – Name des Attributs, das das unmittelbare Ziel ist. Dieses Attribut wird typischerweise von relationship() gemappt, um sich mit einer Zielsammlung zu verbinden, kann aber auch eine Many-to-One- oder eine nicht-skalare Beziehung sein.

• attr – Attribut auf der zugeordneten Instanz oder den zugeordneten Instanzen, das auf Instanzen des Zielobjekts verfügbar ist.

• creator –

  optional.

  Definiert benutzerdefiniertes Verhalten, wenn neue Elemente zur durchgesteuerten Sammlung hinzugefügt werden.

  Standardmäßig löst das Hinzufügen neuer Elemente zur Sammlung die Erstellung einer Instanz des Zielobjekts aus, wobei das gegebene Element als Positionsargument an den Zielkonstruktor übergeben wird. Für Fälle, in denen dies nicht ausreicht, kann association_proxy.creator einen aufrufbaren Wert bereitstellen, der das Objekt auf die entsprechende Weise konstruiert, gegeben das übergebene Element.

  Für Listen- und Mengen-orientierte Sammlungen wird ein einzelnes Argument an die aufrufbare Funktion übergeben. Für Wörterbuch-orientierte Sammlungen werden zwei Argumente übergeben, die dem Schlüssel und dem Wert entsprechen.

  Der aufrufbare Wert association_proxy.creator wird auch für skalare (d. h. Many-to-One, One-to-One) Beziehungen aufgerufen. Wenn der aktuelle Wert des Zielbeziehungsattributs None ist, wird die aufrufbare Funktion verwendet, um ein neues Objekt zu erstellen. Wenn bereits ein Objektwert vorhanden ist, wird der gegebene Attributwert in dieses Objekt geschrieben.

  Siehe auch

  Erstellung neuer Werte

• cascade_scalar_deletes –

  wenn True, zeigt an, dass das Setzen des durchgesteuerten Werts auf None oder das Löschen über del auch das Quellobjekt entfernen sollte. Gilt nur für skalare Attribute. Normalerweise entfernt das Entfernen des durchgesteuerten Ziels nicht das Proxy-Quellobjekt, da dieses Objekt möglicherweise weitere Zustände hat, die noch beibehalten werden sollen.

  Neu in Version 1.3.

  Siehe auch

  Kaskadierendes Löschen von Skalaren - vollständiges Anwendungsbeispiel

• create_on_none_assignment –

  wenn True, zeigt an, dass das Setzen des durchgesteuerten Werts auf None das Quellobjekt **erstellen** sollte, wenn es nicht existiert, unter Verwendung des Erstellers. Gilt nur für skalare Attribute. Dies ist gegenseitig ausschließend gegenüber assocation_proxy.cascade_scalar_deletes.

  Neu in Version 2.0.18.

• init –

  Speziell für Deklarative Dataclass-Abbildung gibt an, ob das zugeordnete Attribut Teil der __init__()-Methode sein soll, wie sie vom Dataclass-Prozess generiert wird.

  Neu ab Version 2.0.0b4.

• repr –

  Speziell für Deklarative Dataclass-Abbildung gibt an, ob das durch dieses AssociationProxy eingerichtete Attribut Teil der __repr__()-Methode sein soll, wie sie vom Dataclass-Prozess generiert wird.

  Neu ab Version 2.0.0b4.

• default_factory –

  Speziell für Deklarative Dataclass-Abbildung gibt eine Standardwert-Generierungsfunktion an, die als Teil der __init__()-Methode ausgeführt wird, wie sie vom Dataclass-Prozess generiert wird.

  Neu ab Version 2.0.0b4.

• compare –

  Speziell für Deklarative Dataclass-Abbildung gibt an, ob dieses Feld bei der Generierung der Methoden __eq__() und __ne__() für die zugeordnete Klasse in Vergleichsoperationen einbezogen werden soll.

  Neu ab Version 2.0.0b4.

• kw_only –

  Speziell für Deklarative Dataclass-Abbildung gibt an, ob dieses Feld als nur-Schlüsselwort-Argument bei der Generierung der __init__()-Methode durch den Dataclass-Prozess markiert werden soll.

  Neu ab Version 2.0.0b4.

• hash –

  Speziell für Deklarative Dataclass-Abbildung steuert, ob dieses Feld bei der Generierung der __hash__()-Methode für die zugeordnete Klasse einbezogen wird.

  Neu in Version 2.0.36.

• info – optional, wird AssociationProxy.info zugewiesen, falls vorhanden.

Die folgenden zusätzlichen Parameter beinhalten die Injektion benutzerdefinierter Verhaltensweisen innerhalb des AssociationProxy-Objekts und sind nur für fortgeschrittene Anwendungsfälle gedacht.

Parameter:

• getset_factory –

  Optional. Der Zugriff auf durchgesteuerte Attribute wird automatisch von Routinen gehandhabt, die Werte basierend auf dem attr-Argument für diesen Proxy abrufen und setzen.

  Wenn Sie dieses Verhalten anpassen möchten, können Sie eine getset_factory-Aufruffunktion bereitstellen, die ein Tupel von getter- und setter-Funktionen erzeugt. Die Fabrik wird mit zwei Argumenten aufgerufen: dem abstrakten Typ der zugrunde liegenden Sammlung und dieser Proxy-Instanz.

• proxy_factory – Optional. Der Typ der zu emulierenden Sammlung wird durch Abtasten der Zielsammlung bestimmt. Wenn Ihr Sammlungstyp nicht durch Duck-Typing bestimmt werden kann oder Sie eine andere Implementierung der Sammlung verwenden möchten, können Sie eine Fabrikfunktion bereitstellen, um diese Sammlungen zu erzeugen. Nur anwendbar auf nicht-skalare Beziehungen.

• proxy_bulk_set – Optional, zusammen mit proxy_factory zu verwenden.

klasse sqlalchemy.ext.associationproxy.AssociationProxy

Ein Deskriptor, der eine Lese-/Schreibansicht eines Objektattributs präsentiert.

Mitglieder

__init__(), cascade_scalar_deletes, create_on_none_assignment, creator, extension_type, for_class(), getset_factory, info, is_aliased_class, is_attribute, is_bundle, is_clause_element, is_instance, is_mapper, is_property, is_selectable, key, proxy_bulk_set, proxy_factory, target_collection, value_attr

Klassensignatur

Klasse sqlalchemy.ext.associationproxy.AssociationProxy (sqlalchemy.orm.base.InspectionAttrInfo, sqlalchemy.orm.base.ORMDescriptor, sqlalchemy.orm._DCAttributeOptions, sqlalchemy.ext.associationproxy._AssociationProxyProtocol)

methode sqlalchemy.ext.associationproxy.AssociationProxy.__init__(target_collection: str, attr: str, *, creator: _CreatorProtocol | None = None, getset_factory: _GetSetFactoryProtocol | None = None, proxy_factory: _ProxyFactoryProtocol | None = None, proxy_bulk_set: _ProxyBulkSetProtocol | None = None, info: _InfoType | None = None, cascade_scalar_deletes: bool = False, create_on_none_assignment: bool = False, attribute_options: _AttributeOptions | None = None)

Konstruiere ein neues AssociationProxy.

Das AssociationProxy-Objekt wird typischerweise mit der Konstruktorfunktion association_proxy() erstellt. Siehe die Beschreibung von association_proxy() für eine Beschreibung aller Parameter.

attribut sqlalchemy.ext.associationproxy.AssociationProxy.cascade_scalar_deletes: bool

attribut sqlalchemy.ext.associationproxy.AssociationProxy.create_on_none_assignment: bool

attribut sqlalchemy.ext.associationproxy.AssociationProxy.creator: _CreatorProtocol | None

attribut sqlalchemy.ext.associationproxy.AssociationProxy.extension_type: InspectionAttrExtensionType = 'ASSOCIATION_PROXY'

Der Erweiterungstyp, falls vorhanden. Standard ist NotExtension.NOT_EXTENSION

Siehe auch

HybridExtensionType

AssociationProxyExtensionType

methode sqlalchemy.ext.associationproxy.AssociationProxy.for_class(class_: Type[Any], obj: object | None = None) → AssociationProxyInstance[_T]

Gibt den internen Zustand zurück, der lokal für eine bestimmte zugeordnete Klasse ist.

Z. B. für eine Klasse User

class User(Base):
    # ...

    keywords = association_proxy("kws", "keyword")

Wenn wir auf dieses AssociationProxy von Mapper.all_orm_descriptors zugreifen und die Zielklasse für diesen Proxy, wie sie von User zugeordnet wird, anzeigen möchten.

inspect(User).all_orm_descriptors["keywords"].for_class(User).target_class

Dies gibt eine Instanz von AssociationProxyInstance zurück, die spezifisch für die Klasse User ist. Das AssociationProxy-Objekt bleibt von seiner übergeordneten Klasse unabhängig.

Parameter:

• class_ – die Klasse, für die wir den Zustand zurückgeben.

• obj – optional, eine Instanz der Klasse, die erforderlich ist, wenn das Attribut auf ein poly-morphisches Ziel verweist, z. B. wenn wir den Typ des tatsächlichen Zielobjekts betrachten müssen, um den vollständigen Pfad zu erhalten.

Neu in Version 1.3: - AssociationProxy speichert keinen zustandsspezifischen Zustand mehr für eine bestimmte übergeordnete Klasse; der Zustand wird nun in pro-Klasse AssociationProxyInstance-Objekten gespeichert.

attribut sqlalchemy.ext.associationproxy.AssociationProxy.getset_factory: _GetSetFactoryProtocol | None

attribut sqlalchemy.ext.associationproxy.AssociationProxy.info

geerbt von dem InspectionAttrInfo.info Attribut von InspectionAttrInfo

Info-Wörterbuch, das dem Objekt zugeordnet ist und es ermöglicht, benutzerdefinierte Daten diesem InspectionAttr zuzuordnen.

Das Wörterbuch wird beim ersten Zugriff generiert. Alternativ kann es als Konstruktorargument für die Funktionen column_property(), relationship() oder composite() angegeben werden.

Siehe auch

QueryableAttribute.info

SchemaItem.info

attribut sqlalchemy.ext.associationproxy.AssociationProxy.is_aliased_class = False

geerbt von dem InspectionAttr.is_aliased_class Attribut von InspectionAttr

True, wenn dieses Objekt eine Instanz von AliasedClass ist.

attribut sqlalchemy.ext.associationproxy.AssociationProxy.is_attribute = True

True, wenn dieses Objekt ein Python Deskriptor ist.

Dies kann sich auf einen von vielen Typen beziehen. Normalerweise ein QueryableAttribute, der Attributereignisse im Namen einer MapperProperty behandelt. Kann aber auch ein Erweiterungstyp sein, wie z. B. AssociationProxy oder hybrid_property. Die InspectionAttr.extension_type bezieht sich auf eine Konstante, die den spezifischen Untertyp identifiziert.

Siehe auch

Mapper.all_orm_descriptors

attribut sqlalchemy.ext.associationproxy.AssociationProxy.is_bundle = False

geerbt von dem InspectionAttr.is_bundle Attribut von InspectionAttr

True, wenn dieses Objekt eine Instanz von Bundle ist.

Attribut sqlalchemy.ext.associationproxy.AssociationProxy.is_clause_element = False

vererbt von der InspectionAttr.is_clause_element Attribut von InspectionAttr

True, wenn dieses Objekt eine Instanz von ClauseElement ist.

Attribut sqlalchemy.ext.associationproxy.AssociationProxy.is_instance = False

vererbt von der InspectionAttr.is_instance Attribut von InspectionAttr

True, wenn dieses Objekt eine Instanz von InstanceState ist.

Attribut sqlalchemy.ext.associationproxy.AssociationProxy.is_mapper = False

vererbt von der InspectionAttr.is_mapper Attribut von InspectionAttr

True, wenn dieses Objekt eine Instanz von Mapper ist.

Attribut sqlalchemy.ext.associationproxy.AssociationProxy.is_property = False

vererbt von der InspectionAttr.is_property Attribut von InspectionAttr

True, wenn dieses Objekt eine Instanz von MapperProperty ist.

Attribut sqlalchemy.ext.associationproxy.AssociationProxy.is_selectable = False

vererbt von der InspectionAttr.is_selectable Attribut von InspectionAttr

Gibt True zurück, wenn dieses Objekt eine Instanz von Selectable ist.

Attribut sqlalchemy.ext.associationproxy.AssociationProxy.key: str

Attribut sqlalchemy.ext.associationproxy.AssociationProxy.proxy_bulk_set: _ProxyBulkSetProtocol | None

Attribut sqlalchemy.ext.associationproxy.AssociationProxy.proxy_factory: _ProxyFactoryProtocol | None

Attribut sqlalchemy.ext.associationproxy.AssociationProxy.target_collection: str

Attribut sqlalchemy.ext.associationproxy.AssociationProxy.value_attr: str

Klasse sqlalchemy.ext.associationproxy.AssociationProxyInstance

Ein pro-Klasse-Objekt, das klassen- und objektspezifische Ergebnisse liefert.

Dies wird von AssociationProxy verwendet, wenn es in Bezug auf eine bestimmte Klasse oder Instanz einer Klasse aufgerufen wird, d. h. wenn es als regulärer Python-Deskriptor verwendet wird.

Wenn AssociationProxy als normaler Python-Deskriptor referenziert wird, ist AssociationProxyInstance das Objekt, das tatsächlich die Informationen bereitstellt. Unter normalen Umständen ist seine Präsenz transparent.

>>> User.keywords.scalar
False

In dem Sonderfall, dass das AssociationProxy-Objekt direkt aufgerufen wird, um einen expliziten Zugriff auf AssociationProxyInstance zu erhalten, verwenden Sie die Methode AssociationProxy.for_class().

proxy_state = inspect(User).all_orm_descriptors["keywords"].for_class(User)

# view if proxy object is scalar or not
>>> proxy_state.scalar
False

Neu in Version 1.3.

Mitglieder

__eq__(), __le__(), __lt__(), __ne__(), all_(), any(), any_(), asc(), attr, between(), bitwise_and(), bitwise_lshift(), bitwise_not(), bitwise_or(), bitwise_rshift(), bitwise_xor(), bool_op(), collate(), collection_class, concat(), contains(), delete(), desc(), distinct(), endswith(), for_proxy(), get(), has(), icontains(), iendswith(), ilike(), in_(), info, is_(), is_distinct_from(), is_not(), is_not_distinct_from(), isnot(), isnot_distinct_from(), istartswith(), like(), local_attr, match(), not_ilike(), not_in(), not_like(), notilike(), notin_(), notlike(), nulls_first(), nulls_last(), nullsfirst(), nullslast(), op(), operate(), parent, regexp_match(), regexp_replace(), remote_attr, reverse_operate(), scalar, set(), startswith(), target_class, timetuple

Klassensignatur

class sqlalchemy.ext.associationproxy.AssociationProxyInstance (sqlalchemy.orm.base.SQLORMOperations)

Methode sqlalchemy.ext.associationproxy.AssociationProxyInstance.__eq__(other: Any) → ColumnOperators

vererbt von der sqlalchemy.sql.expression.ColumnOperators.__eq__ Methode von ColumnOperators

Implementiert den == Operator.

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

Methode sqlalchemy.ext.associationproxy.AssociationProxyInstance.__le__(other: Any) → ColumnOperators

vererbt von der sqlalchemy.sql.expression.ColumnOperators.__le__ Methode von ColumnOperators

Implementiert den Operator <=.

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

Methode sqlalchemy.ext.associationproxy.AssociationProxyInstance.__lt__(other: Any) → ColumnOperators

vererbt von der sqlalchemy.sql.expression.ColumnOperators.__lt__ Methode von ColumnOperators

Implementiert den Operator <.

In einem Spaltenkontext wird die Klausel a < b erzeugt.

Methode sqlalchemy.ext.associationproxy.AssociationProxyInstance.__ne__(other: Any) → ColumnOperators

vererbt von der sqlalchemy.sql.expression.ColumnOperators.__ne__ Methode von ColumnOperators

Implementiert den Operator !=.

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

Methode sqlalchemy.ext.associationproxy.AssociationProxyInstance.all_() → ColumnOperators

vererbt von der ColumnOperators.all_() Methode von 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 Legacy-Version dieser Methode, der Methode Comparator.all(), die spezifisch für ARRAY ist und einen anderen Aufrufstil verwendet, zu verwechseln.

Methode sqlalchemy.ext.associationproxy.AssociationProxyInstance.any(criterion: _ColumnExpressionArgument[bool] | None = None, **kwargs: Any) → ColumnElement[bool]

Erzeugt einen proxysteuerten 'any'-Ausdruck unter Verwendung von EXISTS.

Dieser Ausdruck wird ein zusammengesetztes Produkt sein, das die Operatoren Comparator.any() und/oder Comparator.has() der zugrunde liegenden proxysteuerten Attribute verwendet.

Methode sqlalchemy.ext.associationproxy.AssociationProxyInstance.any_() → ColumnOperators

vererbt von der ColumnOperators.any_() Methode von 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 Legacy-Version dieser Methode, der Methode Comparator.any(), die spezifisch für ARRAY ist und einen anderen Aufrufstil verwendet, zu verwechseln.

Methode sqlalchemy.ext.associationproxy.AssociationProxyInstance.asc() → ColumnOperators

vererbt von der ColumnOperators.asc() Methode von ColumnOperators

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

Attribut sqlalchemy.ext.associationproxy.AssociationProxyInstance.attr

Gibt ein Tupel von (local_attr, remote_attr) zurück.

Dieses Attribut war ursprünglich dazu gedacht, die Methode Query.join() zu erleichtern, um über beide Beziehungen gleichzeitig zu joinen, dies nutzt jedoch einen veralteten Aufrufstil.

Um select.join() oder Query.join() mit einem Association Proxy zu verwenden, besteht die aktuelle Methode darin, die Attribute AssociationProxyInstance.local_attr und AssociationProxyInstance.remote_attr separat zu verwenden.

stmt = (
    select(Parent)
    .join(Parent.proxied.local_attr)
    .join(Parent.proxied.remote_attr)
)

Eine zukünftige Version könnte versuchen, ein prägnanteres Join-Muster für Association Proxy Attribute bereitzustellen.

Siehe auch

AssociationProxyInstance.local_attr

AssociationProxyInstance.remote_attr

Methode sqlalchemy.ext.associationproxy.AssociationProxyInstance.zwischen(cleft: Any, cright: Any, symmetrisch: bool = False) → ColumnOperators

geerbt von der ColumnOperators.between() Methode von ColumnOperators

Erzeugt eine between()-Klausel gegen das Elternobjekt, gegeben den unteren und oberen Bereich.

Methode sqlalchemy.ext.associationproxy.AssociationProxyInstance.bitwise_and(other: Any) → ColumnOperators

geerbt von der ColumnOperators.bitwise_and() Methode von ColumnOperators

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

Neu in Version 2.0.2.

Siehe auch

Bitweise Operatoren

Methode sqlalchemy.ext.associationproxy.AssociationProxyInstance.bitwise_lshift(other: Any) → ColumnOperators

geerbt von der ColumnOperators.bitwise_lshift() Methode von ColumnOperators

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

Neu in Version 2.0.2.

Siehe auch

Bitweise Operatoren

Methode sqlalchemy.ext.associationproxy.AssociationProxyInstance.bitwise_not() → ColumnOperators

geerbt von der ColumnOperators.bitwise_not() Methode von ColumnOperators

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

Neu in Version 2.0.2.

Siehe auch

Bitweise Operatoren

Methode sqlalchemy.ext.associationproxy.AssociationProxyInstance.bitwise_or(other: Any) → ColumnOperators

geerbt von der ColumnOperators.bitwise_or() Methode von ColumnOperators

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

Neu in Version 2.0.2.

Siehe auch

Bitweise Operatoren

Methode sqlalchemy.ext.associationproxy.AssociationProxyInstance.bitwise_rshift(other: Any) → ColumnOperators

geerbt von der ColumnOperators.bitwise_rshift() Methode von ColumnOperators

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

Neu in Version 2.0.2.

Siehe auch

Bitweise Operatoren

Methode sqlalchemy.ext.associationproxy.AssociationProxyInstance.bitwise_xor(other: Any) → ColumnOperators

geerbt von der ColumnOperators.bitwise_xor() Methode von ColumnOperators

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

Neu in Version 2.0.2.

Siehe auch

Bitweise Operatoren

Methode sqlalchemy.ext.associationproxy.AssociationProxyInstance.bool_op(opstring: str, precedence: int = 0, python_impl: Callable[[...], Any] | None = None) → Callable[[Any], Operators]

geerbt von der Operators.bool_op() Methode von Operators

Gibt einen benutzerdefinierten booleschen Operator zurück.

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

Siehe auch

Operators.op()

Methode sqlalchemy.ext.associationproxy.AssociationProxyInstance.collate(collation: str) → ColumnOperators

geerbt von der ColumnOperators.collate() Methode von ColumnOperators

Erzeugt eine collate()-Klausel gegen das Elternobjekt, gegeben den Collation-String.

Siehe auch

collate()

Attribut sqlalchemy.ext.associationproxy.AssociationProxyInstance.collection_class: Type[Any] | None

Methode sqlalchemy.ext.associationproxy.AssociationProxyInstance.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.ext.associationproxy.AssociationProxyInstance.enthält(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 Wildcard-Zeichen "%" und "_", die im <other>-Ausdruck vorkommen, ebenfalls wie Wildcards. Für literale Zeichenkettenwerte kann das Flag ColumnOperators.contains.autoescape auf True gesetzt werden, um Escape-Zeichen für Vorkommen dieser Zeichen innerhalb des Zeichenkettenwerts anzuwenden, damit sie als sie selbst 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 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 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.like()

Methode sqlalchemy.ext.associationproxy.AssociationProxyInstance.delete(obj: Any) → None

Methode sqlalchemy.ext.associationproxy.AssociationProxyInstance.desc() → ColumnOperators

geerbt von der ColumnOperators.desc() Methode von ColumnOperators

Erzeugt eine desc()-Klausel gegen das Elternobjekt.

Methode sqlalchemy.ext.associationproxy.AssociationProxyInstance.distinct() → ColumnOperators

geerbt von der ColumnOperators.distinct() Methode von ColumnOperators

Erzeugt eine distinct()-Klausel gegen das Elternobjekt.

Methode sqlalchemy.ext.associationproxy.AssociationProxyInstance.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 Wildcard-Zeichen "%" und "_", die im <other>-Ausdruck vorkommen, ebenfalls wie Wildcards. Für literale Zeichenkettenwerte kann das Flag ColumnOperators.endswith.autoescape auf True gesetzt werden, um Escape-Zeichen für Vorkommen dieser Zeichen innerhalb des Zeichenkettenwerts anzuwenden, damit sie als sie selbst 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 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 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.startswith()

ColumnOperators.contains()

ColumnOperators.like()

classmethod sqlalchemy.ext.associationproxy.AssociationProxyInstance.for_proxy(parent: AssociationProxy[_T], owning_class: Type[Any], parent_instance: Any) → AssociationProxyInstance[_T]

Methode sqlalchemy.ext.associationproxy.AssociationProxyInstance.get(obj: Any) → _T | None | AssociationProxyInstance[_T]

Methode sqlalchemy.ext.associationproxy.AssociationProxyInstance.has(criterion: _ColumnExpressionArgument[bool] | None = None, **kwargs: Any) → ColumnElement[bool]

Erzeugt einen proxysierten „has“-Ausdruck unter Verwendung von EXISTS.

Dieser Ausdruck wird ein zusammengesetztes Produkt sein, das die Operatoren Comparator.any() und/oder Comparator.has() der zugrunde liegenden proxysteuerten Attribute verwendet.

Methode sqlalchemy.ext.associationproxy.AssociationProxyInstance.icontains(other: Any, **kw: Any) → ColumnOperators

geerbt von der ColumnOperators.icontains() Methode von ColumnOperators

Implementiert den icontains-Operator, 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, fungieren Platzhalterzeichen "%" und "_", die im <other>-Ausdruck vorhanden sind, ebenfalls als Platzhalter. Für literale Zeichenfolgenwerte kann das Flag ColumnOperators.icontains.autoescape auf True gesetzt werden, um Vorkommen dieser Zeichen innerhalb des Zeichenfolgenwerts zu escapen, damit sie als sie selbst und nicht als Platzhalterzeichen übereinstimmen. Alternativ etabliert der Parameter ColumnOperators.icontains.escape ein gegebenes Zeichen als Escape-Zeichen, was nützlich sein kann, wenn der Zielausdruck keine literale Zeichenfolge ist.

Parameter:

• other – der zu vergleichende Ausdruck. Dies ist normalerweise ein einfacher Zeichenfolgenwert, kann aber auch ein beliebiger SQL-Ausdruck sein. LIKE-Platzhalterzeichen % 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

ColumnOperators.contains()

method sqlalchemy.ext.associationproxy.AssociationProxyInstance.iendswith(other: Any, escape: str | None = None, autoescape: bool = False) → ColumnOperators

vererbt von der ColumnOperators.iendswith() Methode von ColumnOperators

Implementiert den Operator iendswith, z. B. die Groß-/Kleinschreibung-unempfindliche 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, fungieren Platzhalterzeichen "%" und "_", die im <other>-Ausdruck vorhanden sind, ebenfalls als Platzhalter. Für literale Zeichenfolgenwerte kann das Flag ColumnOperators.iendswith.autoescape auf True gesetzt werden, um Vorkommen dieser Zeichen innerhalb des Zeichenfolgenwerts zu escapen, damit sie als sie selbst und nicht als Platzhalterzeichen übereinstimmen. Alternativ etabliert der Parameter ColumnOperators.iendswith.escape ein gegebenes Zeichen als Escape-Zeichen, was nützlich sein kann, wenn der Zielausdruck keine literale Zeichenfolge ist.

Parameter:

• other – der zu vergleichende Ausdruck. Dies ist normalerweise ein einfacher Zeichenfolgenwert, kann aber auch ein beliebiger SQL-Ausdruck sein. LIKE-Platzhalterzeichen % 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()

method sqlalchemy.ext.associationproxy.AssociationProxyInstance.ilike(other: Any, escape: str | None = None) → ColumnOperators

vererbt 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.like()

method sqlalchemy.ext.associationproxy.AssociationProxyInstance.in_(other: Any) → ColumnOperators

vererbt 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.

• eine select()-Konstruktion, die normalerweise eine korrelierte Skalarselektion 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, eine select()-Konstruktion oder eine bindparam()-Konstruktion, die das Flag bindparam.expanding auf True gesetzt enthält.

attribute sqlalchemy.ext.associationproxy.AssociationProxyInstance.info

method sqlalchemy.ext.associationproxy.AssociationProxyInstance.is_(other: Any) → ColumnOperators

vererbt 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

ColumnOperators.is_not()

method sqlalchemy.ext.associationproxy.AssociationProxyInstance.is_distinct_from(other: Any) → ColumnOperators

vererbt 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".

method sqlalchemy.ext.associationproxy.AssociationProxyInstance.is_not(other: Any) → ColumnOperators

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

method sqlalchemy.ext.associationproxy.AssociationProxyInstance.is_not_distinct_from(other: Any) → ColumnOperators

vererbt 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.

method sqlalchemy.ext.associationproxy.AssociationProxyInstance.isnot(other: Any) → ColumnOperators

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

method sqlalchemy.ext.associationproxy.AssociationProxyInstance.isnot_distinct_from(other: Any) → ColumnOperators

vererbt 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.

method sqlalchemy.ext.associationproxy.AssociationProxyInstance.istartswith(other: Any, escape: str | None = None, autoescape: bool = False) → ColumnOperators

vererbt von der ColumnOperators.istartswith() Methode von ColumnOperators

Implementiert den Operator istartswith, z. B. die Groß-/Kleinschreibung-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, fungieren Platzhalterzeichen "%" und "_", die im <other>-Ausdruck vorhanden sind, ebenfalls als Platzhalter. Für literale Zeichenfolgenwerte kann das Flag ColumnOperators.istartswith.autoescape auf True gesetzt werden, um Vorkommen dieser Zeichen innerhalb des Zeichenfolgenwerts zu escapen, damit sie als sie selbst und nicht als Platzhalterzeichen übereinstimmen. Alternativ etabliert der Parameter ColumnOperators.istartswith.escape ein gegebenes Zeichen als Escape-Zeichen, was nützlich sein kann, wenn der Zielausdruck keine literale Zeichenfolge ist.

Parameter:

• other – der zu vergleichende Ausdruck. Dies ist normalerweise ein einfacher Zeichenfolgenwert, kann aber auch ein beliebiger SQL-Ausdruck sein. LIKE-Platzhalterzeichen % und _ werden standardmäßig nicht escaped, 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()

method sqlalchemy.ext.associationproxy.AssociationProxyInstance.like(other: Any, escape: str | None = None) → ColumnOperators

vererbt 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 – zu vergleichender Ausdruck

• escape –

  optionales Escape-Zeichen, rendert das ESCAPE Schlüsselwort, z. B.

  somecolumn.like("foo/%bar", escape="/")

Siehe auch

ColumnOperators.ilike()

attribute sqlalchemy.ext.associationproxy.AssociationProxyInstance.local_attr

Das „lokale“ Klassenattribut, auf das sich diese AssociationProxyInstance bezieht.

Siehe auch

AssociationProxyInstance.attr

AssociationProxyInstance.remote_attr

method sqlalchemy.ext.associationproxy.AssociationProxyInstance.match(other: Any, **kwargs: Any) → ColumnOperators

vererbt von der ColumnOperators.match() Methode von ColumnOperators

Implementiert einen datenbankspezifischen 'match'-Operator.

ColumnOperators.match() versucht, zu einer MATCH-ähnlichen Funktion oder einem Operator aufzulösen, der von Backend bereitgestellt wird. Beispiele hierfür sind

• PostgreSQL - rendert x @@ plainto_tsquery(y)

  Geändert in Version 2.0: plainto_tsquery() wird nun anstelle von to_tsquery() für PostgreSQL verwendet; weitere Informationen zu anderen Formen finden Sie unter Full Text Search.

• 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.ext.associationproxy.AssociationProxyInstance.nicht_ilike(andere: Any, escape: str | None = None) → ColumnOperators

geerbt von der ColumnOperators.nicht_ilike() Methode von ColumnOperators

Implementiert den NOT ILIKE Operator.

Dies ist äquivalent zur Verwendung von 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.ext.associationproxy.AssociationProxyInstance.nicht_in(andere: Any) → ColumnOperators

geerbt von der ColumnOperators.nicht_in() Methode von ColumnOperators

Implementiert den NOT IN Operator.

Dies ist äquivalent zur Verwendung von Negation mit ColumnOperators.in_(), d.h. ~x.in_(y).

Wenn andere 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 "wahr" zu erzeugen. 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.nicht_in() erzeugen standardmäßig einen "statischen" Ausdruck für eine leere IN-Sequenz.

Siehe auch

ColumnOperators.in_()

methode sqlalchemy.ext.associationproxy.AssociationProxyInstance.nicht_like(andere: Any, escape: str | None = None) → ColumnOperators

geerbt von der ColumnOperators.nicht_like() Methode von ColumnOperators

Implementiert den NOT LIKE Operator.

Dies ist äquivalent zur Verwendung von 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.like()

methode sqlalchemy.ext.associationproxy.AssociationProxyInstance.nichtilike(andere: Any, escape: str | None = None) → ColumnOperators

geerbt von der ColumnOperators.nichtilike() Methode von ColumnOperators

Implementiert den NOT ILIKE Operator.

Dies ist äquivalent zur Verwendung von 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.ext.associationproxy.AssociationProxyInstance.notin_(andere: Any) → ColumnOperators

geerbt von der ColumnOperators.notin_() Methode von ColumnOperators

Implementiert den NOT IN Operator.

Dies ist äquivalent zur Verwendung von Negation mit ColumnOperators.in_(), d.h. ~x.in_(y).

Wenn andere 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 "wahr" zu erzeugen. 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.nicht_in() erzeugen standardmäßig einen "statischen" Ausdruck für eine leere IN-Sequenz.

Siehe auch

ColumnOperators.in_()

methode sqlalchemy.ext.associationproxy.AssociationProxyInstance.nichtlike(andere: Any, escape: str | None = None) → ColumnOperators

geerbt von der ColumnOperators.nichtlike() Methode von ColumnOperators

Implementiert den NOT LIKE Operator.

Dies ist äquivalent zur Verwendung von 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.like()

methode sqlalchemy.ext.associationproxy.AssociationProxyInstance.nulls_first() → ColumnOperators

geerbt von der ColumnOperators.nulls_first() Methode von ColumnOperators

Erzeugt eine nulls_first()-Klausel gegen 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.ext.associationproxy.AssociationProxyInstance.nulls_last() → ColumnOperators

geerbt von der ColumnOperators.nulls_last() Methode von ColumnOperators

Erzeugt eine nulls_last()-Klausel gegen 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.ext.associationproxy.AssociationProxyInstance.nullsfirst() → ColumnOperators

geerbt von der ColumnOperators.nullsfirst() Methode von ColumnOperators

Erzeugt eine nulls_first()-Klausel gegen 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.ext.associationproxy.AssociationProxyInstance.nullslast() → ColumnOperators

geerbt von der ColumnOperators.nullslast() Methode von ColumnOperators

Erzeugt eine nulls_last()-Klausel gegen 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.ext.associationproxy.AssociationProxyInstance.op(opstring: str, präzedenz: int = 0, ist_vergleich: bool = False, rückgabetyp: 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 – ein String, der als Infix-Operator zwischen diesem Element und dem an die generierte Funktion übergebenen Ausdruck ausgegeben wird.

• präzedenz –

  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 benutze op() um einen benutzerdefinierten Operator zu generieren und meine Klammern werden nicht richtig gerendert - detaillierte Beschreibung, wie der SQLAlchemy SQL-Compiler Klammern rendert

• ist_vergleich –

  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 ist_vergleich wird durch die Verwendung der Methode Operators.bool_op() ersetzt. Dieser prägnantere Operator setzt diesen Parameter automatisch, bietet aber auch eine korrekte PEP 484-Typunterstützung, da das zurückgegebene Objekt einen "booleschen" Datentyp ausdrückt, d.h. BinaryExpression[bool].

• rückgabetyp – eine TypeEngine-Klasse oder ein Objekt, das den Rückgabetyp eines von diesem Operator erzeugten Ausdrucks erzwingt. Standardmäßig werden Operatoren, die Operators.op.ist_vergleich angeben, auf Boolean aufgelöst, und diejenigen, die dies nicht tun, haben denselben 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()

Neudefinition und Erstellung neuer Operatoren

Verwendung benutzerdefinierter Operatoren in Verknüpfungsbedingungen

methode sqlalchemy.ext.associationproxy.AssociationProxyInstance.operate(op: OperatorType, *andere: 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 auf einer Unterklasse kann allgemeines Verhalten auf alle Operationen anwenden. Zum Beispiel kann das Überschreiben von ColumnOperators, um 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.

• *andere – die „andere“ Seite der Operation. Für die meisten Operationen ist dies ein einzelner Skalar.

• **kwargs – Modifikatoren. Diese können von speziellen Operatoren wie ColumnOperators.contains() übergeben werden.

attribut sqlalchemy.ext.associationproxy.AssociationProxyInstance.parent: _AssociationProxyProtocol[_T]

methode sqlalchemy.ext.associationproxy.AssociationProxyInstance.regexp_match(muster: 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, eine vom Backend bereitgestellte REGEXP-ähnliche Funktion oder einen Operator zu verwenden. Die spezifische Syntax regulärer Ausdrücke 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:

• muster – Der reguläre Ausdruck als String oder eine Spaltenklausel.

• flags – Alle anzuwendenden Flags für reguläre Ausdrücke, die nur als einfacher Python-String übergeben werden. Diese Flags sind Backend-spezifisch. Einige Backends wie PostgreSQL und MariaDB können die Flags alternativ als Teil des Musters angeben. Bei Verwendung des Ignorieren-Groß-/Kleinschreibung-Flags „i“ in PostgreSQL wird der REGEXP-Operator mit Ignorieren-Groß-/Kleinschreibung ~* 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()

methode sqlalchemy.ext.associationproxy.AssociationProxyInstance.regexp_replace(muster: Any, ersetzung: 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(..)", "X
Y", flags="g")
)

ColumnOperators.regexp_replace() versucht, eine REGEXP_REPLACE-ähnliche Funktion zu verwenden, 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:

• muster – Der reguläre Ausdruck als String oder eine Spaltenklausel.

• ersetzung – Der Ersetzungs-String oder eine Spaltenklausel.

• flags – Alle anzuwendenden Flags für reguläre Ausdrücke, die nur als einfacher Python-String übergeben werden. 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()

Attribut sqlalchemy.ext.associationproxy.AssociationProxyInstance.remote_attr

Das durch diese AssociationProxyInstance referenzierte ‚remote‘ Klassenattribut.

Siehe auch

AssociationProxyInstance.attr

AssociationProxyInstance.local_attr

Methode sqlalchemy.ext.associationproxy.AssociationProxyInstance.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 dieselbe wie bei operate().

Attribut sqlalchemy.ext.associationproxy.AssociationProxyInstance.scalar

Gibt True zurück, wenn diese AssociationProxyInstance lokal eine skalare Beziehung proxy-t.

Methode sqlalchemy.ext.associationproxy.AssociationProxyInstance.set(obj: Any, values: _T) → None

Methode sqlalchemy.ext.associationproxy.AssociationProxyInstance.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 <other>-Ausdruck vorhanden sind, ebenfalls wie Wildcards. Für literale Zeichenfolgenwerte kann das Flag ColumnOperators.startswith.autoescape auf True gesetzt werden, um Vorkommen dieser Zeichen in der Zeichenfolgenwert zu escapen, damit sie als sie selbst und nicht als Wildcard-Zeichen übereinstimmen. Alternativ etabliert der Parameter ColumnOperators.startswith.escape ein gegebenes Zeichen als Escape-Zeichen, was nützlich sein kann, wenn der Zielausdruck keine literale Zeichenfolge ist.

Parameter:

• other – Ausdruck, der verglichen werden soll. Dies ist normalerweise ein einfacher Zeichenfolgenwert, kann aber auch ein beliebiger SQL-Ausdruck sein. LIKE-Wildcard-Zeichen % und _ werden standardmäßig nicht escaped, 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()

ColumnOperators.like()

Attribut sqlalchemy.ext.associationproxy.AssociationProxyInstance.target_class: Type[Any]

Die von dieser AssociationProxyInstance behandelte Zwischenklasse.

Abgefangene Append-/Set-/Zuweisungsereignisse führen zur Erzeugung neuer Instanzen dieser Klasse.

Attribut sqlalchemy.ext.associationproxy.AssociationProxyInstance.timetuple: Literal[None] = None

geerbt von dem ColumnOperators.timetuple Attribut von ColumnOperators

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

Klasse sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance

eine AssociationProxyInstance, die ein Objekt als Ziel hat.

Mitglieder

__le__(), __lt__(), all_(), any(), any_(), asc(), attr, between(), bitwise_and(), bitwise_lshift(), bitwise_not(), bitwise_or(), bitwise_rshift(), bitwise_xor(), bool_op(), collate(), concat(), contains(), desc(), distinct(), endswith(), has(), icontains(), iendswith(), ilike(), in_(), is_(), is_distinct_from(), is_not(), is_not_distinct_from(), isnot(), isnot_distinct_from(), istartswith(), like(), local_attr, match(), not_ilike(), not_in(), not_like(), notilike(), notin_(), notlike(), nulls_first(), nulls_last(), nullsfirst(), nullslast(), op(), operate(), regexp_match(), regexp_replace(), remote_attr, reverse_operate(), scalar, startswith(), target_class, timetuple

Klassensignatur

class sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance (sqlalchemy.ext.associationproxy.AssociationProxyInstance)

Methode sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance.__le__(other: Any) → ColumnOperators

vererbt von der sqlalchemy.sql.expression.ColumnOperators.__le__ Methode von ColumnOperators

Implementiert den Operator <=.

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

Methode sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance.__lt__(other: Any) → ColumnOperators

vererbt von der sqlalchemy.sql.expression.ColumnOperators.__lt__ Methode von ColumnOperators

Implementiert den Operator <.

In einem Spaltenkontext wird die Klausel a < b erzeugt.

Methode sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance.all_() → ColumnOperators

vererbt von der ColumnOperators.all_() Methode von 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 Legacy-Version dieser Methode, der Methode Comparator.all(), die spezifisch für ARRAY ist und einen anderen Aufrufstil verwendet, zu verwechseln.

Methode sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance.any(criterion: _ColumnExpressionArgument[bool] | None = None, **kwargs: Any) → ColumnElement[bool]

geerbt von der AssociationProxyInstance.any() Methode von AssociationProxyInstance

Erzeugt einen proxysteuerten 'any'-Ausdruck unter Verwendung von EXISTS.

Dieser Ausdruck wird ein zusammengesetztes Produkt sein, das die Operatoren Comparator.any() und/oder Comparator.has() der zugrunde liegenden proxysteuerten Attribute verwendet.

Methode sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance.any_() → ColumnOperators

vererbt von der ColumnOperators.any_() Methode von 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 Legacy-Version dieser Methode, der Methode Comparator.any(), die spezifisch für ARRAY ist und einen anderen Aufrufstil verwendet, zu verwechseln.

Methode sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance.asc() → ColumnOperators

vererbt von der ColumnOperators.asc() Methode von ColumnOperators

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

Attribut sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance.attr

geerbt von dem AssociationProxyInstance.attr Attribut von AssociationProxyInstance

Gibt ein Tupel von (local_attr, remote_attr) zurück.

Dieses Attribut war ursprünglich dazu gedacht, die Methode Query.join() zu erleichtern, um über beide Beziehungen gleichzeitig zu joinen, dies nutzt jedoch einen veralteten Aufrufstil.

Um select.join() oder Query.join() mit einem Association Proxy zu verwenden, besteht die aktuelle Methode darin, die Attribute AssociationProxyInstance.local_attr und AssociationProxyInstance.remote_attr separat zu verwenden.

stmt = (
    select(Parent)
    .join(Parent.proxied.local_attr)
    .join(Parent.proxied.remote_attr)
)

Eine zukünftige Version könnte versuchen, ein prägnanteres Join-Muster für Association Proxy Attribute bereitzustellen.

Siehe auch

AssociationProxyInstance.local_attr

AssociationProxyInstance.remote_attr

Methode sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance.between(cleft: Any, cright: Any, symmetric: bool = False) → ColumnOperators

geerbt von der ColumnOperators.between() Methode von ColumnOperators

Erzeugt eine between()-Klausel gegen das Elternobjekt, gegeben den unteren und oberen Bereich.

Methode sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance.bitwise_and(other: Any) → ColumnOperators

geerbt von der ColumnOperators.bitwise_and() Methode von ColumnOperators

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

Neu in Version 2.0.2.

Siehe auch

Bitweise Operatoren

Methode sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance.bitwise_lshift(other: Any) → ColumnOperators

geerbt von der ColumnOperators.bitwise_lshift() Methode von ColumnOperators

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

Neu in Version 2.0.2.

Siehe auch

Bitweise Operatoren

Methode sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance.bitwise_not() → ColumnOperators

geerbt von der ColumnOperators.bitwise_not() Methode von ColumnOperators

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

Neu in Version 2.0.2.

Siehe auch

Bitweise Operatoren

Methode sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance.bitwise_or(other: Any) → ColumnOperators

geerbt von der ColumnOperators.bitwise_or() Methode von ColumnOperators

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

Neu in Version 2.0.2.

Siehe auch

Bitweise Operatoren

Methode sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance.bitwise_rshift(other: Any) → ColumnOperators

geerbt von der ColumnOperators.bitwise_rshift() Methode von ColumnOperators

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

Neu in Version 2.0.2.

Siehe auch

Bitweise Operatoren

Methode sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance.bitwise_xor(other: Any) → ColumnOperators

geerbt von der ColumnOperators.bitwise_xor() Methode von ColumnOperators

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

Neu in Version 2.0.2.

Siehe auch

Bitweise Operatoren

Methode sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance.bool_op(opstring: str, precedence: int = 0, python_impl: Callable[[...], Any] | None = None) → Callable[[Any], Operators]

geerbt von der Operators.bool_op() Methode von 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 wesentlicher Vorteil der Verwendung von Operators.bool_op() ist, dass bei der Verwendung von Spaltenkonstrukten die "boolesche" Natur des zurückgegebenen Ausdrucks für PEP 484-Zwecke vorhanden ist.

Siehe auch

Operators.op()

Methode sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance.collate(collation: str) → ColumnOperators

geerbt von der ColumnOperators.collate() Methode von ColumnOperators

Erzeugt eine collate()-Klausel gegen das Elternobjekt, gegeben den Collation-String.

Siehe auch

collate()

Methode sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance.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.ext.associationproxy.ObjectAssociationProxyInstance.contains(other: Any, **kw: Any) → ColumnElement[bool]

Erzeugt einen proxyt-en ‚contains‘-Ausdruck unter Verwendung von EXISTS.

Dieser Ausdruck ist ein zusammengesetztes Produkt, das die Operatoren Comparator.any(), Comparator.has() und/oder Comparator.contains() der zugrundeliegenden proxyt-ten Attribute verwendet.

methode sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance.desc() → ColumnOperators

geerbt von der ColumnOperators.desc() Methode von ColumnOperators

Erzeugt eine desc()-Klausel gegen das Elternobjekt.

methode sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance.distinct() → ColumnOperators

geerbt von der ColumnOperators.distinct() Methode von ColumnOperators

Erzeugt eine distinct()-Klausel gegen das Elternobjekt.

methode sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance.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 Wildcard-Zeichen "%" und "_", die im <other>-Ausdruck vorkommen, ebenfalls wie Wildcards. Für literale Zeichenkettenwerte kann das Flag ColumnOperators.endswith.autoescape auf True gesetzt werden, um Escape-Zeichen für Vorkommen dieser Zeichen innerhalb des Zeichenkettenwerts anzuwenden, damit sie als sie selbst 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 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.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.startswith()

ColumnOperators.contains()

ColumnOperators.like()

methode sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance.has(criterion: _ColumnExpressionArgument[bool] | None = None, **kwargs: Any) → ColumnElement[bool]

geerbt von der AssociationProxyInstance.has() Methode von AssociationProxyInstance

Erzeugt einen proxysierten „has“-Ausdruck unter Verwendung von EXISTS.

Dieser Ausdruck wird ein zusammengesetztes Produkt sein, das die Operatoren Comparator.any() und/oder Comparator.has() der zugrunde liegenden proxysteuerten Attribute verwendet.

methode sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance.icontains(other: Any, **kw: Any) → ColumnOperators

geerbt von der ColumnOperators.icontains() Methode von ColumnOperators

Implementiert den icontains-Operator, 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, fungieren Platzhalterzeichen "%" und "_", die im <other>-Ausdruck vorhanden sind, ebenfalls als Platzhalter. Für literale Zeichenfolgenwerte kann das Flag ColumnOperators.icontains.autoescape auf True gesetzt werden, um Vorkommen dieser Zeichen innerhalb des Zeichenfolgenwerts zu escapen, damit sie als sie selbst und nicht als Platzhalterzeichen übereinstimmen. Alternativ etabliert der Parameter ColumnOperators.icontains.escape ein gegebenes Zeichen als Escape-Zeichen, was nützlich sein kann, wenn der Zielausdruck keine literale Zeichenfolge 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.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

ColumnOperators.contains()

methode sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance.iendswith(other: Any, escape: str | None = None, autoescape: bool = False) → ColumnOperators

vererbt von der ColumnOperators.iendswith() Methode von ColumnOperators

Implementiert den Operator iendswith, z. B. die Groß-/Kleinschreibung-unempfindliche 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, fungieren Platzhalterzeichen "%" und "_", die im <other>-Ausdruck vorhanden sind, ebenfalls als Platzhalter. Für literale Zeichenfolgenwerte kann das Flag ColumnOperators.iendswith.autoescape auf True gesetzt werden, um Vorkommen dieser Zeichen innerhalb des Zeichenfolgenwerts zu escapen, damit sie als sie selbst und nicht als Platzhalterzeichen übereinstimmen. Alternativ etabliert der Parameter ColumnOperators.iendswith.escape ein gegebenes Zeichen als Escape-Zeichen, was nützlich sein kann, wenn der Zielausdruck keine literale Zeichenfolge 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.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.ext.associationproxy.ObjectAssociationProxyInstance.ilike(other: Any, escape: str | None = None) → ColumnOperators

vererbt 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 – Ausdruck, der verglichen werden soll

• escape –

  optionales Escape-Zeichen, rendert das ESCAPE Schlüsselwort, z. B.

  somecolumn.ilike("foo/%bar", escape="/")

Siehe auch

ColumnOperators.like()

methode sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance.in_(other: Any) → ColumnOperators

vererbt 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.

• eine select()-Konstruktion, die normalerweise eine korrelierte Skalarselektion 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.ext.associationproxy.ObjectAssociationProxyInstance.is_(other: Any) → ColumnOperators

vererbt 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

ColumnOperators.is_not()

methode sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance.is_distinct_from(other: Any) → ColumnOperators

vererbt 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.ext.associationproxy.ObjectAssociationProxyInstance.is_not(other: Any) → ColumnOperators

vererbt 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.ext.associationproxy.ObjectAssociationProxyInstance.is_not_distinct_from(other: Any) → ColumnOperators

vererbt 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.ext.associationproxy.ObjectAssociationProxyInstance.isnot(other: Any) → ColumnOperators

vererbt 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.ext.associationproxy.ObjectAssociationProxyInstance.isnot_distinct_from(other: Any) → ColumnOperators

vererbt 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.ext.associationproxy.ObjectAssociationProxyInstance.istartswith(other: Any, escape: str | None = None, autoescape: bool = False) → ColumnOperators

vererbt von der ColumnOperators.istartswith() Methode von ColumnOperators

Implementiert den Operator istartswith, z. B. die Groß-/Kleinschreibung-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, fungieren Platzhalterzeichen "%" und "_", die im <other>-Ausdruck vorhanden sind, ebenfalls als Platzhalter. Für literale Zeichenfolgenwerte kann das Flag ColumnOperators.istartswith.autoescape auf True gesetzt werden, um Vorkommen dieser Zeichen innerhalb des Zeichenfolgenwerts zu escapen, damit sie als sie selbst und nicht als Platzhalterzeichen übereinstimmen. Alternativ etabliert der Parameter ColumnOperators.istartswith.escape ein gegebenes Zeichen als Escape-Zeichen, was nützlich sein kann, wenn der Zielausdruck keine literale Zeichenfolge 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.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.ext.associationproxy.ObjectAssociationProxyInstance.like(other: Any, escape: str | None = None) → ColumnOperators

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

attribut sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance.local_attr

geerbt von dem AssociationProxyInstance.local_attr Attribut von AssociationProxyInstance

Das „lokale“ Klassenattribut, auf das sich diese AssociationProxyInstance bezieht.

Siehe auch

AssociationProxyInstance.attr

AssociationProxyInstance.remote_attr

methode sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance.match(other: Any, **kwargs: Any) → ColumnOperators

vererbt von der ColumnOperators.match() Methode von ColumnOperators

Implementiert einen datenbankspezifischen 'match'-Operator.

ColumnOperators.match() versucht, zu einer MATCH-ähnlichen Funktion oder einem Operator aufzulösen, der von Backend bereitgestellt wird. Beispiele hierfür sind

• PostgreSQL - rendert x @@ plainto_tsquery(y)

  Geändert in Version 2.0: plainto_tsquery() wird nun anstelle von to_tsquery() für PostgreSQL verwendet; weitere Informationen zu anderen Formen finden Sie unter Full Text Search.

• 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.ext.associationproxy.ObjectAssociationProxyInstance.not_ilike(other: Any, escape: str | None = None) → ColumnOperators

geerbt von der ColumnOperators.nicht_ilike() Methode von ColumnOperators

Implementiert den NOT ILIKE Operator.

Dies ist äquivalent zur Verwendung von 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.ext.associationproxy.ObjectAssociationProxyInstance.not_in(other: Any) → ColumnOperators

geerbt von der ColumnOperators.nicht_in() Methode von ColumnOperators

Implementiert den NOT IN Operator.

Dies ist äquivalent zur Verwendung von Negation mit ColumnOperators.in_(), d.h. ~x.in_(y).

Wenn andere 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 "wahr" zu erzeugen. 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.nicht_in() erzeugen standardmäßig einen "statischen" Ausdruck für eine leere IN-Sequenz.

Siehe auch

ColumnOperators.in_()

methode sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance.not_like(other: Any, escape: str | None = None) → ColumnOperators

geerbt von der ColumnOperators.nicht_like() Methode von ColumnOperators

Implementiert den NOT LIKE Operator.

Dies ist äquivalent zur Verwendung von 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.like()

methode sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance.notilike(other: Any, escape: str | None = None) → ColumnOperators

geerbt von der ColumnOperators.nichtilike() Methode von ColumnOperators

Implementiert den NOT ILIKE Operator.

Dies ist äquivalent zur Verwendung von 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.ext.associationproxy.ObjectAssociationProxyInstance.notin_(other: Any) → ColumnOperators

geerbt von der ColumnOperators.notin_() Methode von ColumnOperators

Implementiert den NOT IN Operator.

Dies ist äquivalent zur Verwendung von Negation mit ColumnOperators.in_(), d.h. ~x.in_(y).

Wenn andere 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 "wahr" zu erzeugen. 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.nicht_in() erzeugen standardmäßig einen "statischen" Ausdruck für eine leere IN-Sequenz.

Siehe auch

ColumnOperators.in_()

methode sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance.notlike(other: Any, escape: str | None = None) → ColumnOperators

geerbt von der ColumnOperators.nichtlike() Methode von ColumnOperators

Implementiert den NOT LIKE Operator.

Dies ist äquivalent zur Verwendung von 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.like()

methode sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance.nulls_first() → ColumnOperators

geerbt von der ColumnOperators.nulls_first() Methode von ColumnOperators

Erzeugt eine nulls_first()-Klausel gegen 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.ext.associationproxy.ObjectAssociationProxyInstance.nulls_last() → ColumnOperators

geerbt von der ColumnOperators.nulls_last() Methode von ColumnOperators

Erzeugt eine nulls_last()-Klausel gegen 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.ext.associationproxy.ObjectAssociationProxyInstance.nullsfirst() → ColumnOperators

geerbt von der ColumnOperators.nullsfirst() Methode von ColumnOperators

Erzeugt eine nulls_first()-Klausel gegen 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.ext.associationproxy.ObjectAssociationProxyInstance.nullslast() → ColumnOperators

geerbt von der ColumnOperators.nullslast() Methode von ColumnOperators

Erzeugt eine nulls_last()-Klausel gegen 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.ext.associationproxy.ObjectAssociationProxyInstance.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 – ein String, der 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 benutze op() um einen benutzerdefinierten Operator zu generieren und meine Klammern werden nicht richtig gerendert - 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 prägnantere Operator setzt diesen Parameter automatisch, bietet aber auch korrekte PEP 484-Typunterstützung, da das zurückgegebene Objekt einen „boolean“-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 erzwingt. Standardmäßig werden Operatoren, die Operators.op.is_comparison angeben, zu Boolean aufgelöst, und diejenigen, die dies nicht tun, haben denselben 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()

Neudefinition und Erstellung neuer Operatoren

Verwendung benutzerdefinierter Operatoren in Verknüpfungsbedingungen

methode sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance.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 auf einer Unterklasse kann allgemeines Verhalten auf alle Operationen anwenden. Zum Beispiel kann das Überschreiben von ColumnOperators, um 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. Für die meisten Operationen ist dies ein einzelner Skalar.

• **kwargs – Modifikatoren. Diese können von speziellen Operatoren wie ColumnOperators.contains() übergeben werden.

methode sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance.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, eine vom Backend bereitgestellte REGEXP-ähnliche Funktion oder einen Operator zu verwenden. Die spezifische Syntax regulärer Ausdrücke 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 – Das Muster für den regulären Ausdruck oder die Spaltenklausel.

• flags – Alle zu verwendenden Flags für reguläre Ausdrücke, nur als einfacher Python-String übergeben. Diese Flags sind vom Backend abhängig. 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 „Ignore Case“-Operator für reguläre Ausdrücke ~* 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()

methode sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance.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(..)", "X
Y", flags="g")
)

ColumnOperators.regexp_replace() versucht, eine REGEXP_REPLACE-ähnliche Funktion zu verwenden, 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 – Das Muster für den regulären Ausdruck oder die Spaltenklausel.

• pattern – Der Ersatz-String oder die Spaltenklausel.

• flags – Alle zu verwendenden Flags für reguläre Ausdrücke, nur als einfacher Python-String übergeben. Diese Flags sind vom Backend abhängig. 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()

attribut sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance.remote_attr

geerbt vom AssociationProxyInstance.remote_attr Attribut von AssociationProxyInstance

Das durch diese AssociationProxyInstance referenzierte ‚remote‘ Klassenattribut.

Siehe auch

AssociationProxyInstance.attr

AssociationProxyInstance.local_attr

methode sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance.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 dieselbe wie bei operate().

attribut sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance.scalar

geerbt vom AssociationProxyInstance.scalar Attribut von AssociationProxyInstance

Gibt True zurück, wenn diese AssociationProxyInstance lokal eine skalare Beziehung proxy-t.

methode sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance.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 <other>-Ausdruck vorhanden sind, ebenfalls wie Wildcards. Für literale Zeichenfolgenwerte kann das Flag ColumnOperators.startswith.autoescape auf True gesetzt werden, um Vorkommen dieser Zeichen in der Zeichenfolgenwert zu escapen, damit sie als sie selbst und nicht als Wildcard-Zeichen übereinstimmen. Alternativ etabliert der Parameter ColumnOperators.startswith.escape ein gegebenes Zeichen als Escape-Zeichen, was nützlich sein kann, wenn der Zielausdruck keine literale Zeichenfolge ist.

Parameter:

• other – Ausdruck, der verglichen werden soll. Dies ist normalerweise ein einfacher String-Wert, kann aber auch ein beliebiger SQL-Ausdruck sein. LIKE-Wildcard-Zeichen % und _ werden standardmäßig nicht escaped, 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()

ColumnOperators.like()

attribut sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance.target_class: Type[Any]

Die von dieser AssociationProxyInstance behandelte Zwischenklasse.

Abgefangene Append-/Set-/Zuweisungsereignisse führen zur Erzeugung neuer Instanzen dieser Klasse.

attribut sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance.timetuple: Literal[None] = None

geerbt von dem ColumnOperators.timetuple Attribut von ColumnOperators

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

klasse sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance

eine AssociationProxyInstance, die eine Datenbankspalte als Ziel hat.

Mitglieder

__le__(), __lt__(), __ne__(), all_(), any(), any_(), asc(), attr, between(), bitwise_and(), bitwise_lshift(), bitwise_not(), bitwise_or(), bitwise_rshift(), bitwise_xor(), bool_op(), collate(), concat(), contains(), desc(), distinct(), endswith(), has(), icontains(), iendswith(), ilike(), in_(), is_(), is_distinct_from(), is_not(), is_not_distinct_from(), isnot(), isnot_distinct_from(), istartswith(), like(), local_attr, match(), not_ilike(), not_in(), not_like(), notilike(), notin_(), notlike(), nulls_first(), nulls_last(), nullsfirst(), nullslast(), op(), operate(), regexp_match(), regexp_replace(), remote_attr, reverse_operate(), scalar, startswith(), target_class, timetuple

Klassensignatur

klasse sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance (sqlalchemy.ext.associationproxy.AssociationProxyInstance)

methode sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.__le__(other: Any) → ColumnOperators

vererbt von der sqlalchemy.sql.expression.ColumnOperators.__le__ Methode von ColumnOperators

Implementiert den Operator <=.

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

methode sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.__lt__(other: Any) → ColumnOperators

vererbt von der sqlalchemy.sql.expression.ColumnOperators.__lt__ Methode von ColumnOperators

Implementiert den Operator <.

In einem Spaltenkontext wird die Klausel a < b erzeugt.

methode sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.__ne__(other: Any) → ColumnOperators

vererbt von der sqlalchemy.sql.expression.ColumnOperators.__ne__ Methode von ColumnOperators

Implementiert den Operator !=.

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

methode sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.all_() → ColumnOperators

vererbt von der ColumnOperators.all_() Methode von 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 Legacy-Version dieser Methode, der Methode Comparator.all(), die spezifisch für ARRAY ist und einen anderen Aufrufstil verwendet, zu verwechseln.

methode sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.any(criterion: _ColumnExpressionArgument[bool] | None = None, **kwargs: Any) → ColumnElement[bool]

geerbt von der AssociationProxyInstance.any() Methode von AssociationProxyInstance

Erzeugt einen proxysteuerten 'any'-Ausdruck unter Verwendung von EXISTS.

Dieser Ausdruck wird ein zusammengesetztes Produkt sein, das die Operatoren Comparator.any() und/oder Comparator.has() der zugrunde liegenden proxysteuerten Attribute verwendet.

methode sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.any_() → ColumnOperators

vererbt von der ColumnOperators.any_() Methode von 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 Legacy-Version dieser Methode, der Methode Comparator.any(), die spezifisch für ARRAY ist und einen anderen Aufrufstil verwendet, zu verwechseln.

methode sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.asc() → ColumnOperators

vererbt von der ColumnOperators.asc() Methode von ColumnOperators

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

attribut sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.attr

geerbt von dem AssociationProxyInstance.attr Attribut von AssociationProxyInstance

Gibt ein Tupel von (local_attr, remote_attr) zurück.

Dieses Attribut war ursprünglich dazu gedacht, die Methode Query.join() zu erleichtern, um über beide Beziehungen gleichzeitig zu joinen, dies nutzt jedoch einen veralteten Aufrufstil.

Um select.join() oder Query.join() mit einem Association Proxy zu verwenden, besteht die aktuelle Methode darin, die Attribute AssociationProxyInstance.local_attr und AssociationProxyInstance.remote_attr separat zu verwenden.

stmt = (
    select(Parent)
    .join(Parent.proxied.local_attr)
    .join(Parent.proxied.remote_attr)
)

Eine zukünftige Version könnte versuchen, ein prägnanteres Join-Muster für Association Proxy Attribute bereitzustellen.

Siehe auch

AssociationProxyInstance.local_attr

AssociationProxyInstance.remote_attr

methode sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.between(cleft: Any, cright: Any, symmetric: bool = False) → ColumnOperators

geerbt von der ColumnOperators.between() Methode von ColumnOperators

Erzeugt eine between()-Klausel gegen das Elternobjekt, gegeben den unteren und oberen Bereich.

methode sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.bitwise_and(other: Any) → ColumnOperators

geerbt von der ColumnOperators.bitwise_and() Methode von ColumnOperators

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

Neu in Version 2.0.2.

Siehe auch

Bitweise Operatoren

methode sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.bitwise_lshift(other: Any) → ColumnOperators

geerbt von der ColumnOperators.bitwise_lshift() Methode von ColumnOperators

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

Neu in Version 2.0.2.

Siehe auch

Bitweise Operatoren

methode sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.bitwise_not() → ColumnOperators

geerbt von der ColumnOperators.bitwise_not() Methode von ColumnOperators

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

Neu in Version 2.0.2.

Siehe auch

Bitweise Operatoren

Methode sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.bitwise_or(other: Any) → ColumnOperators

geerbt von der ColumnOperators.bitwise_or() Methode von ColumnOperators

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

Neu in Version 2.0.2.

Siehe auch

Bitweise Operatoren

Methode sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.bitwise_rshift(other: Any) → ColumnOperators

geerbt von der ColumnOperators.bitwise_rshift() Methode von ColumnOperators

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

Neu in Version 2.0.2.

Siehe auch

Bitweise Operatoren

Methode sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.bitwise_xor(other: Any) → ColumnOperators

geerbt von der ColumnOperators.bitwise_xor() Methode von ColumnOperators

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

Neu in Version 2.0.2.

Siehe auch

Bitweise Operatoren

Methode sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.bool_op(opstring: str, precedence: int = 0, python_impl: Callable[[...], Any] | None = None) → Callable[[Any], Operators]

geerbt von der Operators.bool_op() Methode von Operators

Gibt einen benutzerdefinierten booleschen Operator zurück.

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

Siehe auch

Operators.op()

Methode sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.collate(collation: str) → ColumnOperators

geerbt von der ColumnOperators.collate() Methode von ColumnOperators

Erzeugt eine collate()-Klausel gegen das Elternobjekt, gegeben den Collation-String.

Siehe auch

collate()

Methode sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.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.ext.associationproxy.ColumnAssociationProxyInstance.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 Wildcard-Zeichen "%" und "_", die im <other>-Ausdruck vorkommen, ebenfalls wie Wildcards. Für literale Zeichenkettenwerte kann das Flag ColumnOperators.contains.autoescape auf True gesetzt werden, um Escape-Zeichen für Vorkommen dieser Zeichen innerhalb des Zeichenkettenwerts anzuwenden, damit sie als sie selbst 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 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 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.like()

Methode sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.desc() → ColumnOperators

geerbt von der ColumnOperators.desc() Methode von ColumnOperators

Erzeugt eine desc()-Klausel gegen das Elternobjekt.

Methode sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.distinct() → ColumnOperators

geerbt von der ColumnOperators.distinct() Methode von ColumnOperators

Erzeugt eine distinct()-Klausel gegen das Elternobjekt.

Methode sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.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 Wildcard-Zeichen "%" und "_", die im <other>-Ausdruck vorkommen, ebenfalls wie Wildcards. Für literale Zeichenkettenwerte kann das Flag ColumnOperators.endswith.autoescape auf True gesetzt werden, um Escape-Zeichen für Vorkommen dieser Zeichen innerhalb des Zeichenkettenwerts anzuwenden, damit sie als sie selbst 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 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 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.startswith()

ColumnOperators.contains()

ColumnOperators.like()

Methode sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.has(criterion: _ColumnExpressionArgument[bool] | None = None, **kwargs: Any) → ColumnElement[bool]

geerbt von der AssociationProxyInstance.has() Methode von AssociationProxyInstance

Erzeugt einen proxysierten „has“-Ausdruck unter Verwendung von EXISTS.

Dieser Ausdruck wird ein zusammengesetztes Produkt sein, das die Operatoren Comparator.any() und/oder Comparator.has() der zugrunde liegenden proxysteuerten Attribute verwendet.

Methode sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.icontains(other: Any, **kw: Any) → ColumnOperators

geerbt von der ColumnOperators.icontains() Methode von ColumnOperators

Implementiert den icontains-Operator, 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, fungieren Platzhalterzeichen "%" und "_", die im <other>-Ausdruck vorhanden sind, ebenfalls als Platzhalter. Für literale Zeichenfolgenwerte kann das Flag ColumnOperators.icontains.autoescape auf True gesetzt werden, um Vorkommen dieser Zeichen innerhalb des Zeichenfolgenwerts zu escapen, damit sie als sie selbst und nicht als Platzhalterzeichen übereinstimmen. Alternativ etabliert der Parameter ColumnOperators.icontains.escape ein gegebenes Zeichen als Escape-Zeichen, was nützlich sein kann, wenn der Zielausdruck keine literale Zeichenfolge 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 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

ColumnOperators.contains()

Methode sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.iendswith(other: Any, escape: str | None = None, autoescape: bool = False) → ColumnOperators

vererbt von der ColumnOperators.iendswith() Methode von ColumnOperators

Implementiert den Operator iendswith, z. B. die Groß-/Kleinschreibung-unempfindliche 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, fungieren Platzhalterzeichen "%" und "_", die im <other>-Ausdruck vorhanden sind, ebenfalls als Platzhalter. Für literale Zeichenfolgenwerte kann das Flag ColumnOperators.iendswith.autoescape auf True gesetzt werden, um Vorkommen dieser Zeichen innerhalb des Zeichenfolgenwerts zu escapen, damit sie als sie selbst und nicht als Platzhalterzeichen übereinstimmen. Alternativ etabliert der Parameter ColumnOperators.iendswith.escape ein gegebenes Zeichen als Escape-Zeichen, was nützlich sein kann, wenn der Zielausdruck keine literale Zeichenfolge 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 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.ext.associationproxy.ColumnAssociationProxyInstance.ilike(other: Any, escape: str | None = None) → ColumnOperators

vererbt 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 – Ausdruck, der verglichen werden soll

• escape –

  optionales Escape-Zeichen, rendert das ESCAPE Schlüsselwort, z. B.

  somecolumn.ilike("foo/%bar", escape="/")

Siehe auch

ColumnOperators.like()

Methode sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.in_(other: Any) → ColumnOperators

vererbt 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.

• eine select()-Konstruktion, die normalerweise eine korrelierte Skalarselektion 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 hat.

Methode sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.is_(other: Any) → ColumnOperators

vererbt 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

ColumnOperators.is_not()

Methode sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.is_distinct_from(other: Any) → ColumnOperators

vererbt 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.ext.associationproxy.ColumnAssociationProxyInstance.is_not(other: Any) → ColumnOperators

vererbt 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.ext.associationproxy.ColumnAssociationProxyInstance.is_not_distinct_from(other: Any) → ColumnOperators

vererbt 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.ext.associationproxy.ColumnAssociationProxyInstance.isnot(other: Any) → ColumnOperators

vererbt 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.ext.associationproxy.ColumnAssociationProxyInstance.isnot_distinct_from(other: Any) → ColumnOperators

vererbt 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.ext.associationproxy.ColumnAssociationProxyInstance.istartswith(other: Any, escape: str | None = None, autoescape: bool = False) → ColumnOperators

vererbt von der ColumnOperators.istartswith() Methode von ColumnOperators

Implementiert den Operator istartswith, z. B. die Groß-/Kleinschreibung-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, fungieren Platzhalterzeichen "%" und "_", die im <other>-Ausdruck vorhanden sind, ebenfalls als Platzhalter. Für literale Zeichenfolgenwerte kann das Flag ColumnOperators.istartswith.autoescape auf True gesetzt werden, um Vorkommen dieser Zeichen innerhalb des Zeichenfolgenwerts zu escapen, damit sie als sie selbst und nicht als Platzhalterzeichen übereinstimmen. Alternativ etabliert der Parameter ColumnOperators.istartswith.escape ein gegebenes Zeichen als Escape-Zeichen, was nützlich sein kann, wenn der Zielausdruck keine literale Zeichenfolge 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 escaped, 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.ext.associationproxy.ColumnAssociationProxyInstance.like(other: Any, escape: str | None = None) → ColumnOperators

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

attribut sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.local_attr

geerbt von dem AssociationProxyInstance.local_attr Attribut von AssociationProxyInstance

Das „lokale“ Klassenattribut, auf das sich diese AssociationProxyInstance bezieht.

Siehe auch

AssociationProxyInstance.attr

AssociationProxyInstance.remote_attr

methode sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.match(other: Any, **kwargs: Any) → ColumnOperators

vererbt von der ColumnOperators.match() Methode von ColumnOperators

Implementiert einen datenbankspezifischen 'match'-Operator.

ColumnOperators.match() versucht, zu einer MATCH-ähnlichen Funktion oder einem Operator aufzulösen, der von Backend bereitgestellt wird. Beispiele hierfür sind

• PostgreSQL - rendert x @@ plainto_tsquery(y)

  Geändert in Version 2.0: plainto_tsquery() wird nun anstelle von to_tsquery() für PostgreSQL verwendet; weitere Informationen zu anderen Formen finden Sie unter Full Text Search.

• 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.ext.associationproxy.ColumnAssociationProxyInstance.not_ilike(other: Any, escape: str | None = None) → ColumnOperators

geerbt von der ColumnOperators.nicht_ilike() Methode von ColumnOperators

Implementiert den NOT ILIKE Operator.

Dies ist äquivalent zur Verwendung von 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.ext.associationproxy.ColumnAssociationProxyInstance.not_in(other: Any) → ColumnOperators

geerbt von der ColumnOperators.nicht_in() Methode von ColumnOperators

Implementiert den NOT IN Operator.

Dies ist äquivalent zur Verwendung von Negation mit ColumnOperators.in_(), d.h. ~x.in_(y).

Wenn andere 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 "wahr" zu erzeugen. 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.nicht_in() erzeugen standardmäßig einen "statischen" Ausdruck für eine leere IN-Sequenz.

Siehe auch

ColumnOperators.in_()

methode sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.not_like(other: Any, escape: str | None = None) → ColumnOperators

geerbt von der ColumnOperators.nicht_like() Methode von ColumnOperators

Implementiert den NOT LIKE Operator.

Dies ist äquivalent zur Verwendung von 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.like()

methode sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.notilike(other: Any, escape: str | None = None) → ColumnOperators

geerbt von der ColumnOperators.nichtilike() Methode von ColumnOperators

Implementiert den NOT ILIKE Operator.

Dies ist äquivalent zur Verwendung von 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.ext.associationproxy.ColumnAssociationProxyInstance.notin_(other: Any) → ColumnOperators

geerbt von der ColumnOperators.notin_() Methode von ColumnOperators

Implementiert den NOT IN Operator.

Dies ist äquivalent zur Verwendung von Negation mit ColumnOperators.in_(), d.h. ~x.in_(y).

Wenn andere 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 "wahr" zu erzeugen. 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.nicht_in() erzeugen standardmäßig einen "statischen" Ausdruck für eine leere IN-Sequenz.

Siehe auch

ColumnOperators.in_()

methode sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.notlike(other: Any, escape: str | None = None) → ColumnOperators

geerbt von der ColumnOperators.nichtlike() Methode von ColumnOperators

Implementiert den NOT LIKE Operator.

Dies ist äquivalent zur Verwendung von 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.like()

methode sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.nulls_first() → ColumnOperators

geerbt von der ColumnOperators.nulls_first() Methode von ColumnOperators

Erzeugt eine nulls_first()-Klausel gegen 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.ext.associationproxy.ColumnAssociationProxyInstance.nulls_last() → ColumnOperators

geerbt von der ColumnOperators.nulls_last() Methode von ColumnOperators

Erzeugt eine nulls_last()-Klausel gegen 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.ext.associationproxy.ColumnAssociationProxyInstance.nullsfirst() → ColumnOperators

geerbt von der ColumnOperators.nullsfirst() Methode von ColumnOperators

Erzeugt eine nulls_first()-Klausel gegen 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.ext.associationproxy.ColumnAssociationProxyInstance.nullslast() → ColumnOperators

geerbt von der ColumnOperators.nullslast() Methode von ColumnOperators

Erzeugt eine nulls_last()-Klausel gegen 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.ext.associationproxy.ColumnAssociationProxyInstance.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 – ein String, der 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 benutze op() um einen benutzerdefinierten Operator zu generieren und meine Klammern werden nicht richtig gerendert - 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 prägnantere 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 erzwingt. Standardmäßig werden Operatoren, die Operators.op.is_comparison angeben, zu Boolean aufgelöst, und diejenigen, die dies nicht tun, haben denselben 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()

Neudefinition und Erstellung neuer Operatoren

Verwendung benutzerdefinierter Operatoren in Verknüpfungsbedingungen

methode sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.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 auf einer Unterklasse kann allgemeines Verhalten auf alle Operationen anwenden. Zum Beispiel kann das Überschreiben von ColumnOperators, um 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.

methode sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.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, eine vom Backend bereitgestellte REGEXP-ähnliche Funktion oder einen Operator zu verwenden. Die spezifische Syntax regulärer Ausdrücke 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 – Der reguläre Ausdruck als String oder Spaltenklausel.

• flags – Alle regulären Ausdrucks-Flags, die angewendet werden sollen, nur als einfacher Python-String. Diese Flags sind Backend-spezifisch. Einige Backends wie PostgreSQL und MariaDB können die Flags auch als Teil des Musters angeben. Bei Verwendung des Flags „i“ für Groß-/Kleinschreibung in PostgreSQL wird der Operator für reguläre Ausdrücke mit Ignorierung der Groß-/Kleinschreibung ~* 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()

methode sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.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(..)", "X
Y", flags="g")
)

ColumnOperators.regexp_replace() versucht, eine REGEXP_REPLACE-ähnliche Funktion zu verwenden, 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 reguläre Ausdruck als String oder Spaltenklausel.

• pattern – Der Ersatzstring oder die Spaltenklausel.

• flags – Alle regulären Ausdrucks-Flags, die angewendet werden sollen, nur als einfacher Python-String. Diese Flags sind Backend-spezifisch. Einige Backends wie PostgreSQL und MariaDB können die Flags auch 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()

attribut sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.remote_attr

geerbt vom AssociationProxyInstance.remote_attr Attribut von AssociationProxyInstance

Das durch diese AssociationProxyInstance referenzierte ‚remote‘ Klassenattribut.

Siehe auch

AssociationProxyInstance.attr

AssociationProxyInstance.local_attr

methode sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.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 dieselbe wie bei operate().

attribut sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.scalar

geerbt vom AssociationProxyInstance.scalar Attribut von AssociationProxyInstance

Gibt True zurück, wenn diese AssociationProxyInstance lokal eine skalare Beziehung proxy-t.

methode sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.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 <other>-Ausdruck vorhanden sind, ebenfalls wie Wildcards. Für literale Zeichenfolgenwerte kann das Flag ColumnOperators.startswith.autoescape auf True gesetzt werden, um Vorkommen dieser Zeichen in der Zeichenfolgenwert zu escapen, damit sie als sie selbst und nicht als Wildcard-Zeichen übereinstimmen. Alternativ etabliert der Parameter ColumnOperators.startswith.escape ein gegebenes Zeichen als Escape-Zeichen, was nützlich sein kann, wenn der Zielausdruck keine literale Zeichenfolge ist.

Parameter:

• other – Ausdruck, der verglichen werden soll. Dies ist normalerweise ein einfacher Stringwert, kann aber auch ein beliebiger SQL-Ausdruck sein. LIKE-Platzhalterzeichen % und _ werden standardmäßig nicht escaped, 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()

ColumnOperators.like()

attribut sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.target_class: Type[Any]

Die von dieser AssociationProxyInstance behandelte Zwischenklasse.

Abgefangene Append-/Set-/Zuweisungsereignisse führen zur Erzeugung neuer Instanzen dieser Klasse.

attribut sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.timetuple: Literal[None] = None

geerbt von dem ColumnOperators.timetuple Attribut von ColumnOperators

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

klasse sqlalchemy.ext.associationproxy.AssociationProxyExtensionType

Eine Aufzählung.

Mitglieder

ASSOCIATION_PROXY

Klassensignatur

class sqlalchemy.ext.associationproxy.AssociationProxyExtensionType (sqlalchemy.orm.base.InspectionAttrExtensionType)

attribut sqlalchemy.ext.associationproxy.AssociationProxyExtensionType.ASSOCIATION_PROXY = 'ASSOCIATION_PROXY'

Symbol, das ein InspectionAttr angibt, das vom Typ AssociationProxy ist.

Wird dem Attribut InspectionAttr.extension_type zugewiesen.