Utiliser des types de données personnalisés dans SQLAlchemy pour les colonnes

SQLAlchemy permet de créer des types de données personnalisés pour les colonnes d’une table, ce qui peut être utile lorsque vous avez des besoins spécifiques pour stocker ou récupérer des données. Par exemple, vous pouvez définir un type personnalisé pour gérer des données complexes ou pour appliquer des transformations lors de l’insertion ou de la récupération des valeurs.

Fonctions :

Définir les types de colonnes

Lors de la création de tables dans une base de données via SQLAlchemy (ORM ou Core), il est nécessaire de définir les colonnes et leurs types de données. On utilise pour cela la classe Column() ainsi que des types tels que Integer, String, Float, Boolean, DateTime, etc. Ces types sont mappés aux types de données des SGBD (SQLite, PostgreSQL, MySQL...). Cela permet de contrôler la structure et les contraintes des tables directement depuis Python.

Importation :

from sqlalchemy import Column, Integer, String, Float, Boolean, DateTime
from sqlalchemy.ext.declarative import declarative_base

Attributs :

Paramètre	Type	Description
`type_`	Type SQLA	Le type de la colonne (Integer, String, Float, Boolean, DateTime...).
`primary_key`	bool	Si la colonne est une clé primaire.
`nullable`	bool	Si la colonne accepte des valeurs NULL (`True` par défaut).
`unique`	bool	Si la colonne impose une contrainte d'unicité.
`default`	valeur	Valeur par défaut de la colonne.
`index`	bool	Si un index doit être créé sur cette colonne.
`autoincrement`	bool	Si la colonne est auto-incrémentée (utilisé en général avec les clés primaires numériques).

Principaux types de données SQLAlchemy :

Type	Description
`Integer`	Entier (équivalent à INTEGER en SQL).
`String(length)`	Chaîne de caractères (VARCHAR). La longueur doit être précisée.
`Text`	Texte long (TEXT).
`Float`	Nombre à virgule flottante (FLOAT).
`Boolean`	Booléen (TRUE/FALSE).
`DateTime`	Date et heure.
`Date`	Date uniquement.
`Time`	Heure uniquement.

Exemple de code :

from sqlalchemy import Column, Integer, String, Float, Boolean, DateTime, create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
import datetime

# Déclaration de la base
Base = declarative_base()

# Définition d'une table 'utilisateurs'
class Utilisateur(Base):
    __tablename__ = 'utilisateurs'

    id = Column(Integer, primary_key=True, autoincrement=True)
    nom = Column(String(50), nullable=False)
    email = Column(String(100), unique=True, nullable=False)
    age = Column(Integer)
    solde = Column(Float, default=0.0)
    est_actif = Column(Boolean, default=True)
    date_creation = Column(DateTime, default=datetime.datetime.utcnow)

# Création de la base SQLite
engine = create_engine('sqlite:///base_de_donnees.db')

# Création des tables
Base.metadata.create_all(engine)

Explication du code :



 	On crée une classe Python représentant la table utilisateurs.
 	Chaque attribut est une colonne définie avec Column() et un type.
 	id : clé primaire, auto-incrémentée.
 	nom : chaîne de 50 caractères, non nullable.
 	email : chaîne de 100 caractères, doit être unique, non nullable.
 	age : entier, optionnel.
 	solde : nombre à virgule flottante, valeur par défaut 0.0.
 	est_actif : booléen, par défaut True.
 	date_creation : date et heure de création, avec une valeur par défaut de datetime.datetime.utcnow.




Remarques :

 	
String(length) est obligatoire pour certaines bases de données (comme MySQL) si on veut contrôler la longueur maximale.

 	
Pour PostgreSQL, SQLAlchemy offre des types spécifiques comme JSON, ARRAY, UUID.

 	
Pour les colonnes DateTime, si vous utilisez default=datetime.datetime.utcnow (sans les parenthèses), vous donnez la fonction comme argument, ce qui permet d’appeler l’heure exacte lors de l’insertion.

 	
Si vous avez besoin d'options avancées comme des contraintes étrangères, des triggers, etc., SQLAlchemy propose également des arguments supplémentaires via ForeignKey, CheckConstraint, etc.