Modularisierung von SQLAlchemy-Modellen mit Mixins und Annotationen

Der Aufbau skalierbarer und wartbarer Modelle erfordert oft einen modularen Ansatz, insbesondere wenn gemeinsame Verhaltensweisen oder gemeinsame Spaltentypen über mehrere Modelle hinweg verarbeitet werden. In diesem Blog erfahren Sie, wie wir Modelle mithilfe der Mixins und Annotationen von SQLAlchemy modularisieren können.
   

Warum modularisieren?

Bei der Arbeit an Projekten stoßen wir häufig auf sich wiederholende Aufgaben, wie das Hinzufügen der Zeitstempel „created_at“ und „update_at“ zu Modellen oder das Definieren gängiger Spaltentypen wie UUID-Primärschlüssel. Die Modularisierung dieser Belange in separate Komponenten hat mehrere Vorteile:
 
1. Wiederverwendbarkeit: Gemeinsame Verhaltensweisen und Spaltendefinitionen können in mehreren Modellen verwendet werden.
2. Wartbarkeit: Änderungen an einer Stelle werden auf alle abhängigen Modelle übertragen.
3. Lesbarkeit: Eine klare Trennung der Belange erleichtert das Verständnis des Codes.

 

Erstellen eines Zeitstempel-Mixins

Mixins stellen wiederverwendbare Logik oder Felder für Modelle bereit. Definieren wir ein TimestampMixin, das automatisch die Felder „created_at“ und „update_at“ zu jedem Modell hinzufügt, das davon erbt.
 
Datei: timestamp_mixin.py

from datetime import datetime
from sqlalchemy import Column, DateTime
from sqlalchemy.ext.declarative import declared_attr

class TimestampMixin:
    @declared_attr
    def created_at(cls):
        return Column(DateTime, default=datetime.utcnow, nullable=False)

    @declared_attr
    def updated_at(cls):
        return Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow, nullable=False)

Erläuterung

• @declared_attr: Stellt sicher, dass die Attribute dynamisch zu den erbenden Modellen hinzugefügt werden.
• Standard und bei Aktualisierung: Zeitstempel für Erstellung und Aktualisierungen automatisch festlegen.

 

Definieren von Gemeinsamen Anmerkungen

Mit den Annotated-Typen von SQLAlchemy, die über Pythons typing.Annotated verfügbar sind, können Sie wiederverwendbare Spalteneigenschaften definieren. Sie können beispielsweise einen UUID-Primärschlüssel oder eine String-Spalte mit bestimmten Einschränkungen definieren.
 
Datei: common_annotations.py

from typing import Annotated
from uuid import uuid4
from sqlalchemy import String
from sqlalchemy.dialects.postgresql import UUID
from sqlalchemy.orm import mapped_column

uuid4pk = 
    mapped_column(UUID(as_uuid=True), primary_key=True, default=uuid4, nullable=False)
]

name = Annotated[
    str,
    mapped_column(String(30), nullable=False)
]

Erläuterung

• UUID-Primärschlüssel: Die uuid4pk-Annotation definiert eine universell eindeutige Kennung für Primärschlüssel.
• Namensspalte: Die Namensanmerkung stellt eine String-Spalte mit einer maximalen Länge von 30 Zeichen und keinen NULL-Werten sicher.

 

Erstellen von Modellen mit Mixins und Anmerkungen

Mithilfe der Mixins und Annotationen können wir Modelle definieren, die gemeinsames Verhalten und Eigenschaften erben und gleichzeitig die Implementierung prägnant und lesbar halten.
 
Datei:user.py

from datetime import datetime
from sqlalchemy import Column, DateTime
from sqlalchemy.ext.declarative import declared_attr

class TimestampMixin:
    @declared_attr
    def created_at(cls):
        return Column(DateTime, default=datetime.utcnow, nullable=False)

    @declared_attr
    def updated_at(cls):
        return Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow, nullable=False)

Erläuterung

• Deklarative Basis: Die Basis dient als Grundlage für alle SQLAlchemy-Modelle.

 

Vorteile dieses Ansatzes

1. Klare Trennung der Belange

• timestamp_mixin.py: Enthält wiederverwendbare Logik (z. B. Zeitstempel).
• common_annotations.py: Definiert allgemeine Spalteneigenschaften (z. B. UUIDs, Zeichenfolgen).
• user.py: Kombiniert diese Bausteine ​​zu konkreten Modellen.

2. Einfache Wartung

• Wenn die Funktionsweise von Zeitstempeln geändert oder Spalteneinschränkungen aktualisiert werden müssen, müssen nur die Dateien timestamp_mixin.py oder common_annotations.py geändert werden. Die Änderungen werden automatisch auf alle abhängigen Modelle übertragen.

3. Skalierbarkeit

• Wenn das Projekt wächst, erleichtert diese Struktur das Hinzufügen neuer Verhaltensweisen oder Feldtypen, ohne dass Redundanz entsteht.

   

Letzte Gedanken

Das Modularisieren von Modellen mit den Mixins und Annotationen von SQLAlchemy ist eine gute Strategie für den Umgang mit gemeinsam genutzten Funktionen und Eigenschaften. Dieser Ansatz reduziert nicht nur Duplikate, sondern steht auch im Einklang mit Best Practices für sauberen, wartbaren Code.

Das obige ist der detaillierte Inhalt vonModularisierung von SQLAlchemy-Modellen mit Mixins und Annotationen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!