Mutationsverfolgung

Bietet Unterstützung für die Verfolgung von Änderungen in-place an skalaren Werten, die in ORM-Änderungsereignisse auf den besitzenden übergeordneten Objekten weitergegeben werden.

Festlegen der Veränderbarkeit von Skalaren Spaltenwerten

Ein typisches Beispiel für eine „veränderbare“ Struktur ist ein Python-Dictionary. Nach dem Beispiel in SQL-Datentyp-Objekte beginnen wir mit einem benutzerdefinierten Typ, der Python-Dictionaries in JSON-Strings umwandelt, bevor sie persistiert werden

from sqlalchemy.types import TypeDecorator, VARCHAR
import json


class JSONEncodedDict(TypeDecorator):
    "Represents an immutable structure as a json-encoded string."

    impl = VARCHAR

    def process_bind_param(self, value, dialect):
        if value is not None:
            value = json.dumps(value)
        return value

    def process_result_value(self, value, dialect):
        if value is not None:
            value = json.loads(value)
        return value

Die Verwendung von json dient nur dem Beispiel. Die Erweiterung sqlalchemy.ext.mutable kann mit jedem Typ verwendet werden, dessen Ziel-Python-Typ veränderbar sein kann, einschließlich PickleType, ARRAY usw.

Bei Verwendung der Erweiterung sqlalchemy.ext.mutable verfolgt der Wert selbst alle übergeordneten Objekte, die darauf verweisen. Nachfolgend illustrieren wir eine einfache Version des MutableDict-Dictionary-Objekts, das die Mutable-Mixin auf ein normales Python-Dictionary anwendet

from sqlalchemy.ext.mutable import Mutable


class MutableDict(Mutable, dict):
    @classmethod
    def coerce(cls, key, value):
        "Convert plain dictionaries to MutableDict."

        if not isinstance(value, MutableDict):
            if isinstance(value, dict):
                return MutableDict(value)

            # this call will raise ValueError
            return Mutable.coerce(key, value)
        else:
            return value

    def __setitem__(self, key, value):
        "Detect dictionary set events and emit change events."

        dict.__setitem__(self, key, value)
        self.changed()

    def __delitem__(self, key):
        "Detect dictionary del events and emit change events."

        dict.__delitem__(self, key)
        self.changed()

Die obige Dictionary-Klasse verwendet den Ansatz, die Python-eigenständige dict zu unterklassifizieren, um eine Dictionary-Unterklasse zu erzeugen, die alle Mutationsereignisse über __setitem__ leitet. Es gibt Varianten dieses Ansatzes, wie z. B. die Unterklassifizierung von UserDict.UserDict oder collections.MutableMapping; entscheidend für dieses Beispiel ist, dass die Methode Mutable.changed() aufgerufen wird, wann immer eine In-place-Änderung an der Datenstruktur stattfindet.

Wir definieren auch die Methode Mutable.coerce() neu, die verwendet wird, um Werte, die keine Instanzen von MutableDict sind, wie z. B. die von dem json-Modul zurückgegebenen normalen Dictionaries, in den entsprechenden Typ umzuwandeln. Die Definition dieser Methode ist optional; wir könnten auch unser JSONEncodedDict so erstellen, dass es immer eine Instanz von MutableDict zurückgibt und zusätzlich sicherstellen, dass aller aufrufende Code MutableDict explizit verwendet. Wenn Mutable.coerce() nicht überschrieben wird, lösen Werte, die einem übergeordneten Objekt zugewiesen werden und keine Instanzen des veränderbaren Typs sind, einen ValueError aus.

Unser neuer MutableDict-Typ bietet eine Klassenmethode Mutable.as_mutable(), die wir innerhalb der Spaltenmetadaten verwenden können, um sie mit Typen zu verknüpfen. Diese Methode greift den gegebenen Typ oder die Klasse und verknüpft einen Listener, der alle zukünftigen Abbildungen dieses Typs erkennt und die Abbildung der Ereignislauscher auf das abgebildete Attribut anwendet. Zum Beispiel, mit klassischen Tabellenmetadaten

from sqlalchemy import Table, Column, Integer

my_data = Table(
    "my_data",
    metadata,
    Column("id", Integer, primary_key=True),
    Column("data", MutableDict.as_mutable(JSONEncodedDict)),
)

Oben gibt Mutable.as_mutable() eine Instanz von JSONEncodedDict zurück (falls der Typ noch keine Instanz war), die alle Attribute abfängt, die gegen diesen Typ abgebildet werden. Nachfolgend richten wir eine einfache Abbildung auf die Tabelle my_data ein

from sqlalchemy.orm import DeclarativeBase
from sqlalchemy.orm import Mapped
from sqlalchemy.orm import mapped_column


class Base(DeclarativeBase):
    pass


class MyDataClass(Base):
    __tablename__ = "my_data"
    id: Mapped[int] = mapped_column(primary_key=True)
    data: Mapped[dict[str, str]] = mapped_column(
        MutableDict.as_mutable(JSONEncodedDict)
    )

Das Mitglied MyDataClass.data wird nun über In-place-Änderungen seines Werts benachrichtigt.

Jede In-place-Änderung am Mitglied MyDataClass.data kennzeichnet das Attribut als „dirty“ (modifiziert) auf dem übergeordneten Objekt

>>> from sqlalchemy.orm import Session

>>> sess = Session(some_engine)
>>> m1 = MyDataClass(data={"value1": "foo"})
>>> sess.add(m1)
>>> sess.commit()

>>> m1.data["value1"] = "bar"
>>> assert m1 in sess.dirty
True

Das MutableDict kann mit allen zukünftigen Instanzen von JSONEncodedDict in einem Schritt verknüpft werden, indem Mutable.associate_with() verwendet wird. Dies ähnelt Mutable.as_mutable(), außer dass es alle Vorkommen von MutableDict in allen Abbildungen bedingungslos abfängt, ohne dass es individuell deklariert werden muss

from sqlalchemy.orm import DeclarativeBase
from sqlalchemy.orm import Mapped
from sqlalchemy.orm import mapped_column

MutableDict.associate_with(JSONEncodedDict)


class Base(DeclarativeBase):
    pass


class MyDataClass(Base):
    __tablename__ = "my_data"
    id: Mapped[int] = mapped_column(primary_key=True)
    data: Mapped[dict[str, str]] = mapped_column(JSONEncodedDict)

Unterstützung für Pickling

Der Schlüssel zur Erweiterung sqlalchemy.ext.mutable beruht auf der Platzierung eines weakref.WeakKeyDictionary auf dem Wertobjekt, das eine Abbildung von übergeordneten abgebildeten Objekten speichert, die mit dem Attributnamen verknüpft sind, unter dem sie mit diesem Wert verbunden sind. WeakKeyDictionary-Objekte sind nicht pickelbar, da sie Weakrefs und Funktions-Callbacks enthalten. In unserem Fall ist das gut so, denn wenn dieses Dictionary pickelbar wäre, könnte dies zu einer übermäßig großen Pickle-Größe für unsere Wertobjekte führen, die für sich allein außerhalb des Kontexts des übergeordneten Objekts gepickelt werden. Die Verantwortung des Entwicklers besteht hier nur darin, eine Methode __getstate__ bereitzustellen, die die Sammlung MutableBase._parents() vom Pickle-Stream ausschließt

class MyMutableType(Mutable):
    def __getstate__(self):
        d = self.__dict__.copy()
        d.pop("_parents", None)
        return d

Mit unserem Dictionary-Beispiel müssen wir die Inhalte des Dictionaries selbst zurückgeben (und sie auch in __setstate__ wiederherstellen)

class MutableDict(Mutable, dict):
    # ....

    def __getstate__(self):
        return dict(self)

    def __setstate__(self, state):
        self.update(state)

Falls unser veränderbares Wertobjekt gepickelt wird, während es an ein oder mehrere übergeordnete Objekte angehängt ist, die ebenfalls Teil des Pickles sind, stellt die Mutable-Mixin die Sammlung Mutable._parents für jedes Wertobjekt wieder her, sobald die besitzenden übergeordneten Objekte entpickelt werden.

Empfangen von Ereignissen

Der Ereignishandler AttributeEvents.modified() kann verwendet werden, um ein Ereignis zu empfangen, wenn ein veränderbarer Skalar ein Änderungsereignis ausgibt. Dieser Ereignishandler wird aufgerufen, wenn die Funktion flag_modified() innerhalb der veränderbaren Erweiterung aufgerufen wird

from sqlalchemy.orm import DeclarativeBase
from sqlalchemy.orm import Mapped
from sqlalchemy.orm import mapped_column
from sqlalchemy import event


class Base(DeclarativeBase):
    pass


class MyDataClass(Base):
    __tablename__ = "my_data"
    id: Mapped[int] = mapped_column(primary_key=True)
    data: Mapped[dict[str, str]] = mapped_column(
        MutableDict.as_mutable(JSONEncodedDict)
    )


@event.listens_for(MyDataClass.data, "modified")
def modified_json(instance, initiator):
    print("json value modified:", instance.data)

Festlegen der Veränderbarkeit von Zusammensetzungen

Zusammensetzungen sind ein spezielles ORM-Feature, das es ermöglicht, einem einzelnen skalaren Attribut einen Objektwert zuzuweisen, der Informationen darstellt, die aus einer oder mehreren Spalten der zugrunde liegenden abgebildeten Tabelle „zusammengesetzt“ sind. Das übliche Beispiel ist ein geometrischer „Punkt“, der in Composite Column Types vorgestellt wird.

Wie bei Mutable unterklassifiziert die benutzerdefinierte Zusammensetzungsklasse MutableComposite als Mixin und erkennt Änderungsereignisse, die über die Methode MutableComposite.changed() an ihre übergeordneten Objekte weitergegeben werden. Im Falle einer Zusammensetzungsklasse erfolgt die Erkennung normalerweise über die Verwendung der speziellen Python-Methode __setattr__(). Im folgenden Beispiel erweitern wir die in Composite Column Types vorgestellte Klasse Point, um MutableComposite in ihre Basen aufzunehmen und Attributzuweisungsereignisse über __setattr__ an die Methode MutableComposite.changed() weiterzuleiten

import dataclasses
from sqlalchemy.ext.mutable import MutableComposite


@dataclasses.dataclass
class Point(MutableComposite):
    x: int
    y: int

    def __setattr__(self, key, value):
        "Intercept set events"

        # set the attribute
        object.__setattr__(self, key, value)

        # alert all parents to the change
        self.changed()

Die Klasse MutableComposite nutzt Klassen-Mapping-Ereignisse, um automatisch Listener für jede Verwendung von composite() einzurichten, die unseren Point-Typ angibt. Unten, wenn Point der Klasse Vertex zugeordnet wird, werden Listener eingerichtet, die Ereignisse von Point-Objekten an jedes der Attribute Vertex.start und Vertex.end weiterleiten

from sqlalchemy.orm import DeclarativeBase, Mapped
from sqlalchemy.orm import composite, mapped_column


class Base(DeclarativeBase):
    pass


class Vertex(Base):
    __tablename__ = "vertices"

    id: Mapped[int] = mapped_column(primary_key=True)

    start: Mapped[Point] = composite(
        mapped_column("x1"), mapped_column("y1")
    )
    end: Mapped[Point] = composite(
        mapped_column("x2"), mapped_column("y2")
    )

    def __repr__(self):
        return f"Vertex(start={self.start}, end={self.end})"

Jede In-place-Änderung an den Mitgliedern Vertex.start oder Vertex.end kennzeichnet das Attribut als „dirty“ (modifiziert) auf dem übergeordneten Objekt

>>> from sqlalchemy.orm import Session
>>> sess = Session(engine)
>>> v1 = Vertex(start=Point(3, 4), end=Point(12, 15))
>>> sess.add(v1)
sql>>> sess.flush()
BEGIN (implicit)
INSERT INTO vertices (x1, y1, x2, y2) VALUES (?, ?, ?, ?)
[...] (3, 4, 12, 15)
>>> v1.end.x = 8
>>> assert v1 in sess.dirty
True
sql>>> sess.commit()
UPDATE vertices SET x2=? WHERE vertices.id = ?
[...] (8, 1)
COMMIT

Umwandlung veränderbarer Zusammensetzungen

Die Methode MutableBase.coerce() wird auch für Zusammensetzungstypen unterstützt. Im Fall von MutableComposite wird die Methode MutableBase.coerce() nur für Attributzuweisungsoperationen aufgerufen, nicht für Ladeoperationen. Das Überschreiben der Methode MutableBase.coerce() ist im Wesentlichen gleichbedeutend mit der Verwendung einer validates() Validierungsroutine für alle Attribute, die den benutzerdefinierten Zusammensetzungstyp verwenden

@dataclasses.dataclass
class Point(MutableComposite):
    # other Point methods
    # ...

    def coerce(cls, key, value):
        if isinstance(value, tuple):
            value = Point(*value)
        elif not isinstance(value, Point):
            raise ValueError("tuple or Point expected")
        return value

Unterstützung für Pickling

Wie bei Mutable verwendet die Hilfsklasse MutableComposite ein weakref.WeakKeyDictionary, das über das Attribut MutableBase._parents() verfügbar ist und nicht pickelbar ist. Wenn wir Instanzen von Point oder seiner besitzenden Klasse Vertex pickeln müssen, müssen wir mindestens eine __getstate__ definieren, die das _parents-Dictionary nicht einschließt. Nachfolgend definieren wir sowohl eine __getstate__ als auch eine __setstate__, die die minimale Form unserer Point-Klasse verpacken

@dataclasses.dataclass
class Point(MutableComposite):
    # ...

    def __getstate__(self):
        return self.x, self.y

    def __setstate__(self, state):
        self.x, self.y = state

Wie bei Mutable ergänzt MutableComposite den Pickling-Prozess des relationalen Objektzustands des übergeordneten Objekts, sodass die Sammlung MutableBase._parents() für alle Point-Objekte wiederhergestellt wird.

API-Referenz

Objektname	Beschreibung
Mutable	Mixin, der die transparente Weitergabe von Änderungsereignissen an ein übergeordnetes Objekt definiert.
MutableBase	Gemeinsame Basisklasse für Mutable und MutableComposite.
MutableComposite	Mixin, der die transparente Weitergabe von Änderungsereignissen auf einem SQLAlchemy-„Zusammensetzungsobjekt“ an seine besitzenden Elternobjekte definiert.
MutableDict	Ein Dictionary-Typ, der Mutable implementiert.
MutableList	Ein Listen-Typ, der Mutable implementiert.
MutableSet	Ein Set-Typ, der Mutable implementiert.

class sqlalchemy.ext.mutable.MutableBase

Mitglieder

_parents, coerce()

Gemeinsame Basisklasse für Mutable und MutableComposite.

attribute sqlalchemy.ext.mutable.MutableBase._parents

Dictionary von InstanceState des übergeordneten Objekts -> Attributname auf dem übergeordneten Objekt.

Dieses Attribut ist eine sogenannte „memoized“ Eigenschaft. Es initialisiert sich beim ersten Zugriff mit einem neuen weakref.WeakKeyDictionary und gibt dasselbe Objekt bei nachfolgenden Zugriffen zurück.

Geändert in Version 1.4: die InstanceState wird nun als Schlüssel im schwachen Dictionary verwendet anstelle der Instanz selbst.

classmethod sqlalchemy.ext.mutable.MutableBase.coerce(key: str, value: Any) → Any | None

Wandelt einen gegebenen Wert in den Zieltyp um.

Kann von benutzerdefinierten Unterklassen überschrieben werden, um eingehende Daten in einen bestimmten Typ umzuwandeln.

Standardmäßig wird ein ValueError ausgelöst.

Diese Methode wird in verschiedenen Szenarien aufgerufen, je nachdem, ob die übergeordnete Klasse vom Typ Mutable oder vom Typ MutableComposite ist. Im ersten Fall wird sie sowohl für Attributzuweisungsoperationen als auch während ORM-Ladeoperationen aufgerufen. Für letzteres wird sie nur während Attributzuweisungsoperationen aufgerufen; die Mechanik des Konstrukts composite() kümmert sich um die Umwandlung während Ladeoperationen.

Parameter:

• key – Zeichenkettenname des ORM-abgebildeten Attributs, das zugewiesen wird.

• value – der eingehende Wert.

Gibt zurück:

Die Methode sollte den umgewandelten Wert zurückgeben oder einen ValueError auslösen, wenn die Umwandlung nicht abgeschlossen werden kann.

class sqlalchemy.ext.mutable.Mutable

Mixin, der die transparente Weitergabe von Änderungsereignissen an ein übergeordnetes Objekt definiert.

Siehe das Beispiel in Festlegen der Veränderbarkeit von Skalaren Spaltenwerten für Nutzungsinformationen.

Mitglieder

_get_listen_keys(), _listen_on_attribute(), _parents, as_mutable(), associate_with(), associate_with_attribute(), changed(), coerce()

Klassensignatur

class sqlalchemy.ext.mutable.Mutable (sqlalchemy.ext.mutable.MutableBase)

classmethod sqlalchemy.ext.mutable.Mutable._get_listen_keys(attribute: QueryableAttribute[Any]) → Set[str]

geerbt von der sqlalchemy.ext.mutable.MutableBase._get_listen_keys Methode von MutableBase

Gibt für ein Deskriptorattribut ein set() der Attributschlüssel zurück, die eine Änderung des Zustands dieses Attributs anzeigen.

Dies ist normalerweise nur set([attribute.key]), kann aber überschrieben werden, um zusätzliche Schlüssel bereitzustellen. Z.B. ergänzt ein MutableComposite diese Menge um die Attributschlüssel, die den Spalten zugeordnet sind, aus denen sich der Zusammensetzungswert zusammensetzt.

Diese Sammlung wird im Falle des Abfangens der Ereignisse InstanceEvents.refresh() und InstanceEvents.refresh_flush() konsultiert, die eine Liste von Attributnamen übergeben, die aktualisiert wurden; die Liste wird mit diesem Satz verglichen, um festzustellen, ob Maßnahmen ergriffen werden müssen.

classmethod sqlalchemy.ext.mutable.Mutable._listen_on_attribute(attribute: QueryableAttribute[Any], coerce: bool, parent_cls: _ExternalEntityType[Any]) → None

geerbt von der sqlalchemy.ext.mutable.MutableBase._listen_on_attribute Methode von MutableBase

Richtet diesen Typ als Mutations-Listener für den gegebenen abgebildeten Deskriptor ein.

attribute sqlalchemy.ext.mutable.Mutable._parents

geerbt von der sqlalchemy.ext.mutable.MutableBase._parents Attribut von MutableBase

Dictionary von InstanceState des übergeordneten Objekts -> Attributname auf dem übergeordneten Objekt.

Dieses Attribut ist eine sogenannte „memoized“ Eigenschaft. Es initialisiert sich beim ersten Zugriff mit einem neuen weakref.WeakKeyDictionary und gibt dasselbe Objekt bei nachfolgenden Zugriffen zurück.

Geändert in Version 1.4: die InstanceState wird nun als Schlüssel im schwachen Dictionary verwendet anstelle der Instanz selbst.

classmethod sqlalchemy.ext.mutable.Mutable.as_mutable(sqltype: _TypeEngineArgument[_T]) → TypeEngine[_T]

Ordnet einem SQL-Typ diesen veränderlichen Python-Typ zu.

Dadurch werden Listener eingerichtet, die ORM-Abbildungen auf den gegebenen Typ erkennen und Mutationsereignis-Tracker zu diesen Abbildungen hinzufügen.

Der Typ wird bedingungslos als Instanz zurückgegeben, damit as_mutable() inline verwendet werden kann

Table(
    "mytable",
    metadata,
    Column("id", Integer, primary_key=True),
    Column("data", MyMutableType.as_mutable(PickleType)),
)

Beachten Sie, dass der zurückgegebene Typ immer eine Instanz ist, auch wenn eine Klasse übergeben wird, und dass nur Spalten, die speziell mit dieser Typinstanz deklariert sind, zusätzliche Instrumentierung erhalten.

Um einen bestimmten veränderlichen Typ allen Vorkommen eines bestimmten Typs zuzuordnen, verwenden Sie die Klassenmethode Mutable.associate_with() der jeweiligen Mutable-Unterklasse, um eine globale Zuordnung herzustellen.

Warnung

Die von dieser Methode eingerichteten Listener sind global für alle Mapper und werden nicht vom Garbage Collector bereinigt. Verwenden Sie as_mutable() nur für Typen, die für eine Anwendung permanent sind, und nicht mit Ad-hoc-Typen, da dies sonst zu einem unbegrenzten Wachstum des Speicherverbrauchs führt.

classmethod sqlalchemy.ext.mutable.Mutable.associate_with(sqltype: type) → None

Ordnet diesen Wrapper allen zukünftigen abgebildeten Spalten des gegebenen Typs zu.

Dies ist eine Hilfsmethode, die automatisch associate_with_attribute aufruft.

Warnung

Die von dieser Methode eingerichteten Listener sind global für alle Mapper und werden nicht vom Garbage Collector bereinigt. Verwenden Sie associate_with() nur für Typen, die für eine Anwendung permanent sind, und nicht mit Ad-hoc-Typen, da dies sonst zu einem unbegrenzten Wachstum des Speicherverbrauchs führt.

classmethod sqlalchemy.ext.mutable.Mutable.associate_with_attribute(attribute: InstrumentedAttribute[_O]) → None

Richtet diesen Typ als Mutations-Listener für den gegebenen abgebildeten Deskriptor ein.

method sqlalchemy.ext.mutable.Mutable.changed() → None

Unterklassen sollten diese Methode aufrufen, wann immer Änderungsereignisse auftreten.

classmethod sqlalchemy.ext.mutable.Mutable.coerce(key: str, value: Any) → Any | None

geerbt von der MutableBase.coerce() Methode von MutableBase

Wandelt einen gegebenen Wert in den Zieltyp um.

Kann von benutzerdefinierten Unterklassen überschrieben werden, um eingehende Daten in einen bestimmten Typ umzuwandeln.

Standardmäßig wird ein ValueError ausgelöst.

Diese Methode wird in verschiedenen Szenarien aufgerufen, je nachdem, ob die übergeordnete Klasse vom Typ Mutable oder vom Typ MutableComposite ist. Im ersten Fall wird sie sowohl für Attributzuweisungsoperationen als auch während ORM-Ladeoperationen aufgerufen. Für letzteres wird sie nur während Attributzuweisungsoperationen aufgerufen; die Mechanik des Konstrukts composite() kümmert sich um die Umwandlung während Ladeoperationen.

Parameter:

• key – Zeichenkettenname des ORM-zugeordneten Attributs, das gesetzt wird.

• value – Der eingehende Wert.

Gibt zurück:

Die Methode sollte den umgewandelten Wert zurückgeben oder einen ValueError auslösen, wenn die Umwandlung nicht abgeschlossen werden kann.

class sqlalchemy.ext.mutable.MutableComposite

Mixin, der die transparente Weitergabe von Änderungsereignissen auf einem SQLAlchemy-„Zusammensetzungsobjekt“ an seine besitzenden Elternobjekte definiert.

Siehe das Beispiel unter Etablierung von Veränderlichkeit für Composites für Nutzungsinformationen.

Mitglieder

changed()

Klassensignatur

class sqlalchemy.ext.mutable.MutableComposite (sqlalchemy.ext.mutable.MutableBase)

method sqlalchemy.ext.mutable.MutableComposite.changed() → None

Unterklassen sollten diese Methode aufrufen, wann immer Änderungsereignisse auftreten.

class sqlalchemy.ext.mutable.MutableDict

Ein Dictionary-Typ, der Mutable implementiert.

Das Objekt MutableDict implementiert ein Dictionary, das Änderungsereignisse an die zugrunde liegende Abbildung sendet, wenn der Inhalt des Dictionarys geändert wird, einschließlich, wenn Werte hinzugefügt oder entfernt werden.

Beachten Sie, dass MutableDict die Mutationsverfolgung für die Werte selbst innerhalb des Dictionarys nicht anwendet. Daher ist es keine ausreichende Lösung für den Anwendungsfall der Verfolgung von tiefgreifenden Änderungen an einer rekursiven Dictionary-Struktur, wie z.B. einer JSON-Struktur. Um diesen Anwendungsfall zu unterstützen, erstellen Sie eine Unterklasse von MutableDict, die eine geeignete Konvertierung für die in das Dictionary eingefügten Werte bietet, damit diese ebenfalls „veränderlich“ sind und Ereignisse an ihre übergeordnete Struktur senden.

Siehe auch

MutableList

MutableSet

Mitglieder

clear(), coerce(), pop(), popitem(), setdefault(), update()

Klassensignatur

class sqlalchemy.ext.mutable.MutableDict (sqlalchemy.ext.mutable.Mutable, builtins.dict, typing.Generic)

method sqlalchemy.ext.mutable.MutableDict.clear() → None.  Entfernt alle Elemente aus D.

classmethod sqlalchemy.ext.mutable.MutableDict.coerce(key: str, value: Any) → MutableDict[_KT, _VT] | None

Konvertiert ein normales Dictionary in eine Instanz dieser Klasse.

method sqlalchemy.ext.mutable.MutableDict.pop(k[, d]) → v, entfernt den angegebenen Schlüssel und gibt den entsprechenden Wert zurück.

Wenn der Schlüssel nicht gefunden wird, wird der Standardwert zurückgegeben, falls vorhanden; andernfalls wird ein KeyError ausgelöst.

method sqlalchemy.ext.mutable.MutableDict.popitem() → Tuple[_KT, _VT]

Entfernt und gibt ein Schlüssel-Wert-Paar als 2-Tupel zurück.

Paare werden in LIFO-Reihenfolge (Last-in, First-out) zurückgegeben. Löst einen KeyError aus, wenn das Dictionary leer ist.

method sqlalchemy.ext.mutable.MutableDict.setdefault(*arg)

Fügt einen Schlüssel mit dem Wert default ein, wenn der Schlüssel nicht im Dictionary vorhanden ist.

Gibt den Wert für den Schlüssel zurück, wenn der Schlüssel im Dictionary vorhanden ist, andernfalls den Standardwert.

method sqlalchemy.ext.mutable.MutableDict.update([E, ]**F) → None.  Aktualisiert D aus dict/iterable E und F.

Wenn E vorhanden ist und eine .keys()-Methode hat, dann wird Folgendes ausgeführt: for k in E: D[k] = E[k] Wenn E vorhanden ist und keine .keys()-Methode hat, dann wird Folgendes ausgeführt: for k, v in E: D[k] = v In beiden Fällen folgt: for k in F: D[k] = F[k]

class sqlalchemy.ext.mutable.MutableList

Ein Listen-Typ, der Mutable implementiert.

Das Objekt MutableList implementiert eine Liste, die Änderungsereignisse an die zugrunde liegende Abbildung sendet, wenn der Inhalt der Liste geändert wird, einschließlich, wenn Werte hinzugefügt oder entfernt werden.

Beachten Sie, dass MutableList die Mutationsverfolgung für die Werte selbst innerhalb der Liste nicht anwendet. Daher ist es keine ausreichende Lösung für den Anwendungsfall der Verfolgung von tiefgreifenden Änderungen an einer rekursiven veränderlichen Struktur, wie z.B. einer JSON-Struktur. Um diesen Anwendungsfall zu unterstützen, erstellen Sie eine Unterklasse von MutableList, die eine geeignete Konvertierung für die in das Dictionary eingefügten Werte bietet, damit diese ebenfalls „veränderlich“ sind und Ereignisse an ihre übergeordnete Struktur senden.

Siehe auch

MutableDict

MutableSet

Mitglieder

append(), clear(), coerce(), extend(), insert(), is_iterable(), is_scalar(), pop(), remove(), reverse(), sort()

Klassensignatur

class sqlalchemy.ext.mutable.MutableList (sqlalchemy.ext.mutable.Mutable, builtins.list, typing.Generic)

method sqlalchemy.ext.mutable.MutableList.append(x: _T) → None

Fügt ein Objekt am Ende der Liste ein.

method sqlalchemy.ext.mutable.MutableList.clear() → None

Entfernt alle Elemente aus der Liste.

classmethod sqlalchemy.ext.mutable.MutableList.coerce(key: str, value: MutableList[_T] | _T) → MutableList[_T] | None

Konvertiert eine normale Liste in eine Instanz dieser Klasse.

method sqlalchemy.ext.mutable.MutableList.extend(x: Iterable[_T]) → None

Erweitert die Liste durch Anhängen von Elementen aus dem Iterable.

method sqlalchemy.ext.mutable.MutableList.insert(i: SupportsIndex, x: _T) → None

Fügt ein Objekt vor dem Index ein.

method sqlalchemy.ext.mutable.MutableList.is_iterable(value: _T | Iterable[_T]) → TypeGuard[Iterable[_T]]

method sqlalchemy.ext.mutable.MutableList.is_scalar(value: _T | Iterable[_T]) → TypeGuard[_T]

method sqlalchemy.ext.mutable.MutableList.pop(*arg: SupportsIndex) → _T

Entfernt und gibt ein Element am Index zurück (standardmäßig das letzte).

Löst einen IndexError aus, wenn die Liste leer ist oder der Index außerhalb des gültigen Bereichs liegt.

method sqlalchemy.ext.mutable.MutableList.remove(i: _T) → None

Entfernt das erste Vorkommen des Werts.

Löst einen ValueError aus, wenn der Wert nicht vorhanden ist.

method sqlalchemy.ext.mutable.MutableList.reverse() → None

Kehrt die Liste *IN PLACE* um.

method sqlalchemy.ext.mutable.MutableList.sort(**kw: Any) → None

Sortiert die Liste aufsteigend und gibt None zurück.

Die Sortierung ist in-place (d.h. die Liste selbst wird geändert) und stabil (d.h. die Reihenfolge von zwei gleichen Elementen wird beibehalten).

Wenn eine Schlüssel-Funktion angegeben ist, wird diese einmal auf jedes Listenelement angewendet und diese dann aufsteigend oder absteigend entsprechend ihrer Funktionswerte sortiert.

Das Reverse-Flag kann gesetzt werden, um absteigend zu sortieren.

class sqlalchemy.ext.mutable.MutableSet

Ein Set-Typ, der Mutable implementiert.

Das Objekt MutableSet implementiert ein Set, das Änderungsereignisse an die zugrunde liegende Abbildung sendet, wenn der Inhalt des Sets geändert wird, einschließlich, wenn Werte hinzugefügt oder entfernt werden.

Beachten Sie, dass MutableSet die Mutationsverfolgung für die Werte selbst innerhalb des Sets nicht anwendet. Daher ist es keine ausreichende Lösung für den Anwendungsfall der Verfolgung von tiefgreifenden Änderungen an einer rekursiven veränderlichen Struktur. Um diesen Anwendungsfall zu unterstützen, erstellen Sie eine Unterklasse von MutableSet, die eine geeignete Konvertierung für die in das Dictionary eingefügten Werte bietet, damit diese ebenfalls „veränderlich“ sind und Ereignisse an ihre übergeordnete Struktur senden.

Siehe auch

MutableDict

MutableList

Mitglieder

add(), clear(), coerce(), difference_update(), discard(), intersection_update(), pop(), remove(), symmetric_difference_update(), update()

Klassensignatur

class sqlalchemy.ext.mutable.MutableSet (sqlalchemy.ext.mutable.Mutable, builtins.set, typing.Generic)

methode sqlalchemy.ext.mutable.MutableSet.add(elem: _T) → None

Ein Element zu einem Set hinzufügen.

Dies hat keine Auswirkung, wenn das Element bereits vorhanden ist.

methode sqlalchemy.ext.mutable.MutableSet.clear() → None

Alle Elemente aus diesem Set entfernen.

classmethod sqlalchemy.ext.mutable.MutableSet.coerce(index: str, value: Any) → MutableSet[_T] | None

Ein normales Set in eine Instanz dieser Klasse konvertieren.

methode sqlalchemy.ext.mutable.MutableSet.difference_update(*arg: Iterable[Any]) → None

Alle Elemente eines anderen Sets aus diesem Set entfernen.

methode sqlalchemy.ext.mutable.MutableSet.discard(elem: _T) → None

Ein Element aus einem Set entfernen, falls es vorhanden ist.

Wenn das Element kein Mitglied ist, tue nichts.

methode sqlalchemy.ext.mutable.MutableSet.intersection_update(*arg: Iterable[Any]) → None

Ein Set mit dem Schnitt von sich selbst und einem anderen aktualisieren.

methode sqlalchemy.ext.mutable.MutableSet.pop(*arg: Any) → _T

Ein beliebiges Element aus einem Set entfernen und zurückgeben. Löst KeyError aus, wenn das Set leer ist.

methode sqlalchemy.ext.mutable.MutableSet.remove(elem: _T) → None

Ein Element aus einem Set entfernen; es muss ein Mitglied sein.

Wenn das Element kein Mitglied ist, wird ein KeyError ausgelöst.

methode sqlalchemy.ext.mutable.MutableSet.symmetric_difference_update(*arg: Iterable[_T]) → None

Ein Set mit der symmetrischen Differenz von sich selbst und einem anderen aktualisieren.

methode sqlalchemy.ext.mutable.MutableSet.update(*arg: Iterable[_T]) → None

Ein Set mit der Vereinigung von sich selbst und anderen aktualisieren.