Tout savoir sur les ORM en Python avec SQLAlchemy : Guide complet et pratique

Vous avez peut-être entendu parler du mappage objet-relationnel (ORM), et en avez même utilisé un. Mais qu'est-ce que c'est exactement ? Comment l'implémenter en Python ?

Voici un guide exhaustif sur les ORM et Python, rédigé par des experts en développement pour vous aider à maîtriser cette technologie essentielle.

Qu'est-ce qu'un ORM ?

Le mappage objet-relationnel (ORM) est une technique de programmation qui facilite l'accès aux bases de données relationnelles via des objets. Au lieu d'écrire des requêtes SQL manuelles pour insérer ou récupérer des données, vous manipulez des attributs et méthodes d'objets.

Cela semble abstrait, mais les ORM économisent un temps précieux et renforcent le contrôle sur l'accès aux données. Prenons un exemple concret : lors de l'insertion d'un mot de passe, vous voulez le hacher systématiquement (comme détaillé dans les bonnes pratiques de sécurité web). Sans ORM, il faut dupliquer ce code partout. Avec un ORM, une logique centralisée s'exécute automatiquement à chaque accès.

Cela crée une "source unique de vérité" : une modification se propage partout. Les ORM s'intègrent parfaitement à la programmation orientée objet (POO) en Python pour un contrôle optimal des bases de données.

Bien sûr, ils ont des limites (performances pour des requêtes complexes, par exemple), mais ils sont indispensables dans les grands projets.

Les ORM en Python avec SQLAlchemy

En Python, importer une bibliothèque comme SQLAlchemy est plus efficace que de développer un ORM maison. Ce tutoriel utilise SQLAlchemy (version stable recommandée), mais les principes s'appliquent à d'autres outils.

Configuration de Python pour SQLAlchemy

Préparez votre environnement avec Python 3.8+ (les versions antérieures nécessitent des ajustements mineurs ; consultez notre FAQ Python pour les détails).

Créez un environnement virtuel pour isoler les dépendances :

python -m venv mon_env
source mon_env/bin/activate  # Linux/Mac
# ou mon_env\Scripts\activate  # Windows

Installez SQLAlchemy via pip :

pip install SQLAlchemy==2.0.23

Vous êtes prêt ! Les exemples utilisent une base SQLite en mémoire, mais adaptez l'URI pour votre SGBD (PostgreSQL, MySQL, etc.).

Les modèles dans SQLAlchemy

Un modèle est une classe Python décrivant une table (équivalent ORM de CREATE TABLE). Créez un fichier test.py :

from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
Base = declarative_base()
engine = create_engine('sqlite:///:memory:')  # Base en mémoire
Base.metadata.create_all(engine)  # Crée les tables

Les imports chargent les outils nécessaires. create_engine établit la connexion ; create_all matérialise les modèles.

Ajoutez les imports pour les colonnes :

from sqlalchemy import Column, Integer, String, ForeignKey
from sqlalchemy.orm import relationship

Créez un modèle simple pour les voitures :

class Car(Base):
    __tablename__ = 'cars'
    id = Column(Integer, primary_key=True)
    make = Column(String(50), nullable=False)
    color = Column(String(50), nullable=False)

Chaque modèle hérite de Base. Les colonnes sont des attributs avec types et contraintes.

Ajoutez un modèle pour les propriétaires, avec relation :

class CarOwner(Base):
    __tablename__ = 'car_owners'
    id = Column(Integer, primary_key=True)
    name = Column(String(50), nullable=False)
    age = Column(Integer, nullable=False)
    car_id = Column(Integer, ForeignKey('cars.id'))
    car = relationship('Car')

Exécutez pour créer les tables (rien de visible sans données).

Manipuler les objets dans SQLAlchemy

Écriture de données

Importez la session :

from sqlalchemy.orm import sessionmaker
Session = sessionmaker(bind=engine)
session = Session()

Insérez une voiture :

car1 = Car(make="Ford", color="argent")
session.add(car1)
session.commit()

Ajoutez un propriétaire :

owner1 = CarOwner(name="Joe", age=99, car_id=car1.id)
session.add(owner1)
session.commit()

SQLAlchemy gère les ID et contraintes automatiquement.

Lecture de données

Interrogez :

results = session.query(Car).all()
print(results[0].color)  # "argent"

Accédez aux relations :

owners = session.query(CarOwner).all()
print(owners[0].name)
print(owners[0].car.color)

Les jointures sont automatiques grâce aux relations.

Les limites des ORM

Les ORM sont puissants, mais :

• Modèles à définir avant usage.
• Nouvelle syntaxe à apprendre.
• Surkill pour projets simples.
• Exige une bonne conception BD initiale.

Pour les bases existantes, utilisez l'auto-mapping. Consultez nos commandes SQL essentielles si les ORM ne conviennent pas.