Modularisation des modèles SQLAlchemy avec des mixins et des annotations

La création de modèles évolutifs et maintenables nécessite souvent une approche modulaire, en particulier lors de la gestion de comportements partagés ou de types de colonnes communs à plusieurs modèles. Dans ce blog, nous expliquerons comment modulariser des modèles à l'aide des mixins et des annotations de SQLAlchemy.
   

Pourquoi modulariser ?

Lorsque nous travaillons sur des projets, nous rencontrons fréquemment des tâches répétitives telles que l'ajout d'horodatages Create_at et Updated_at aux modèles ou la définition de types de colonnes courants comme les clés primaires UUID. La modularisation de ces préoccupations en composants distincts présente plusieurs avantages :
 
1. Réutilisabilité : les comportements partagés et les définitions de colonnes peuvent être utilisés sur plusieurs modèles.
2. Maintenabilité : les modifications centralisées se propagent à tous les modèles dépendants.
3. Lisibilité : Une séparation claire des préoccupations rend le code plus facile à comprendre.

 

Création d'un Timestamp Mixin

Les Mixins fournissent une logique ou des champs réutilisables pour les modèles. Définissons un TimestampMixin qui ajoute automatiquement les champs Created_at et Updated_at à tout modèle qui en hérite.
 
Fichier : 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)

Explication

• @declared_attr : garantit que les attributs sont ajoutés dynamiquement aux modèles héritants.
• par défaut et onupdate : définissez automatiquement les horodatages pour la création et les mises à jour.

 

Définir les Annotations communes

Les types Annotés de SQLAlchemy, disponibles via le typage de Python.Annotés, vous permettent de définir des propriétés de colonnes réutilisables. Par exemple, vous pouvez définir une clé primaire UUID ou une colonne String avec des contraintes spécifiques.
 
Fichier :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)
]

Explication

• Clé primaire UUID : L'annotation uuid4pk définit un identifiant universellement unique pour les clés primaires.
• Colonne de nom : L'annotation de nom garantit une colonne de chaîne d'une longueur maximale de 30 caractères et aucune valeur NULL.

 

Création de modèles avec des mixins et des annotations

En utilisant les mixins et annotations, nous pouvons définir des modèles qui héritent d'un comportement et de propriétés partagés tout en gardant l'implémentation concise et lisible.
 
Fichier : 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)

Explication

• Base déclarative : La base sert de base à tous les modèles SQLAlchemy.

 

Avantages de cette approche

1. Séparation claire des préoccupations

• timestamp_mixin.py : contient une logique réutilisable (par exemple, des horodatages).
• common_annotations.py : définit les propriétés communes des colonnes (par exemple, UUID, chaînes).
• user.py : combine ces éléments de base en modèles concrets.

2. Facilité d'entretien

• S'il est nécessaire de modifier le fonctionnement des horodatages ou de mettre à jour les contraintes de colonne, il suffit de modifier les fichiers timestamp_mixin.py ou common_annotations.py. Les modifications sont automatiquement répercutées sur tous les modèles dépendants.

3. Évolutivité

• À mesure que le projet grandit, cette structure facilite l'ajout de nouveaux comportements ou types de champs sans introduire de redondance.

   

Pensées finales

La modularisation des modèles avec les mixins et les annotations de SQLAlchemy est une bonne stratégie pour gérer les fonctionnalités et les propriétés partagées. Cette approche réduit non seulement la duplication, mais s'aligne également sur les meilleures pratiques pour un code propre et maintenable.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!