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

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 :

  📋 Copy

  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.