SQLAlchemy: Boîte à outils SQL Python et mappeur objet-relationnel

Salut la Communauté !

Dans cet article, nous présentons un aperçu de SQLAlchemy, alors commençons !

SQLAlchemy est une boîte à outils Python SQL qui sert de pont entre votre code Python et le système de base de données relationnelle de votre choix. Créée par Michael Bayer, elle est actuellement disponible en tant que bibliothèque open-source sous la licence MIT. SQLAlchemy prend en charge un large éventail de systèmes de bases de données, notamment PostgreSQL, MySQL, SQLite, Oracle et Microsoft SQL Server, ce qui la rend polyvalente et adaptable aux différentes exigences des projets.

Les outils SQLAlchemy SQL Toolkit et Object Relational Mapper (mappeur objet-relationnel) constituent un jeu complet d'outils pour travailler avec des bases de données et Python. Il comporte plusieurs domaines distincts de fonctionnalité que vous pouvez utiliser individuellement ou dans des combinaisons diverses. Les principaux composants sont illustrés ci-dessous, les dépendances des composants étant organisées en couches :

Comme vous le constatez ci-dessus, les deux parties les plus importantes de SQLAlchemy sont le  mapping objet-relationnel (Object Relational Mapper, ORM) et le the noyau (Core).

Object Relational Mapper(ORM)

Le composant ORM permet de faire correspondre des objets Python à des tables de base de données. Il simplifie l'écriture du code qui interagit avec les bases de données. L'ORM s'appuie sur le Core pour fournir les moyens de travailler avec un modèle d'objet de domaine mappé sur un schéma de base de données. Lorsque vous l'utilisez, vous construisez généralement les instructions SQL de la même manière qu'avec le Core. Cependant, la tâche DML, qui fait référence à la persistance des objets commerciaux dans une base de données, est automatisée à l'aide d'un modèle appelé unité de travail. Il convertit les changements d'état par rapport aux objets variables en constructions INSERT, UPDATE et DELETE qui sont ensuite invoquées en fonction de ces objets. Les instructions SELECT sont complétées par des capacités d'automatisation spécifiques à l'ORM et des capacités d'interrogation centrées sur l'objet.

Ci-dessous, vous pouvez observer un exemple basique de définition d'une classe ORM dans SQLAlchemy :

from sqlalchemy import Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base

Base = declarative_base()

class User(Base):
    __tablename__ = 'users'
    id = Column(Integer, primary_key=True)
    username = Column(String(50), unique=True)
    email = Column(String(100))

En utilisant cette classe, vous pouvez facilement créer, faire une requête, mettre à jour et supprimer des enregistrements d'utilisateurs dans votre base de données.

 

Core

Le composant Core fournit la fonctionnalité sous-jacente pour interagir avec les bases de données, y compris la mise en commun des connexions, la gestion des transactions et la génération d'expressions SQL. L'élément central à la fois du Core et de l'ORM de SQLAlchemy est le langage d'expression SQL qui facilite la construction fluide et composable de requêtes SQL.

Le langage d'expression SQL est une boîte à outils propre, indépendante du paquet ORM. Elle fournit un système de construction d'expressions SQL représentées par des objets composables, qui peuvent ensuite être "exécutées" contre une base de données cible dans le cadre d'une transaction spécifique.

L'ORM est construit sur Core pour fournir les outils permettant de travailler avec un modèle d'objet de domaine mappé sur un schéma de base de données. Lorsque vous l'utilisez, vous construisez généralement les instructions SQL de la même manière qu'avec le Core. Cependant, la tâche DML, qui fait référence à la persistance des objets commerciaux dans une base de données, est automatisée à l'aide d'un modèle appelé unité de travail. Il convertit les changements d'état par rapport aux objets variables en constructions INSERT, UPDATE et DELETE qui sont ensuite invoquées en fonction de ces objets. Les instructions SELECT sont complétées par des capacités d'automatisation spécifiques à l'ORM et des capacités d'interrogation centrées sur l'objet.

Alors que le travail avec le Core et le langage d'expression SQL offre une vue de la base de données centrée sur le schéma, ainsi qu'un paradigme de programmation orienté vers l'immuabilité, l'ORM construit une vue de la base de données centrée sur le domaine, avec un paradigme de programmation qui est plus explicitement orienté vers l'objet et qui repose sur la mutabilité. Une base de données relationnelle étant elle-même un service modifiable, la différence réside dans le fait que le langage d'expression Core/SQL est orienté vers la commande, tandis que l'ORM est orienté vers l'état.

Vous trouverez ci-dessous un exemple de requête SQLAlchemy simple :

from sqlalchemy import create_engine, text

engine = create_engine('sqlite:///my_database.db')
conn = engine.connect()

query = text("SELECT username FROM users WHERE id = :user_id")
result = conn.execute(query, user_id=1)

SQLAlchemy intègre un système de regroupement des connexions qui gère efficacement les connexions aux bases de données. Elle gère automatiquement la création, la réutilisation et la libération des connexions, réduisant ainsi la charge de travail et améliorant les performances des applications ayant des interactions fréquentes avec la base de données.

Utilisation simple des opérations CRUD de SQLAlchemy

1. Établissez la connectivité : le moteur
2. Définissez vos tables de base de données
3. Utilisez l'ORM pour sauvegarder les données
4. Récupérez des données à l'aide de l'ORM

1. Établissement de la connectivité - le moteur

Chaque application SQLAlchemy commence par un objet appelé moteur (Engine). Cet objet agit comme une source centrale de connexions à une base de données particulière, en fournissant à la fois des paramètres de base et un espace de stockage appelé "pool de connexions" pour ces connexions à la base de données. Le moteur est généralement un objet global qui ne doit être créé qu'une seule fois pour un serveur de base de données particulier. Il est généralement configuré à l'aide d'une chaîne d'URL décrivant la manière dont il doit se connecter à l'hôte ou au backend de la base de données.

Nous utiliserons une base de données SQLite de type "en mémoire seulement". Le moteur sera assemblé à l'aide de la fonction create_engine() :

from sqlalchemy import create_engine
engine = create_engine("sqlite+pysqlite:///:memory:", echo=True)

2.  Définition  de vos tables de base de données

Pour faire fonctionner l'OR, il faut d'abord définir les tables de base de données à l'aide des classes Python. Par exemple, la classe Python suivante définit une table User :

from sqlalchemy import SQLAlchemy

db = SQLAlchemy()

class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    email = db.Column(db.String(150), unique=True)
    username = db.Column(db.String(150), unique=True)
    password = db.Column(db.String(150))

3.  Utilisation de l'ORM pour sauvegarder les données

Pour accéder à la table User, nous devons importer User à partir de notre classe de modèle, et exploiter ensuite l'objet session pour ajouter des données :

from models import User
from sqlalchemy import SQLAlchemy

db = SQLAlchemy()

new_user = User(email="email address", username="username", password="Password"))
db.session.add(new_user)
db.session.commit()

4. Récupération de données à l'aide d'ORM

Nous utiliserons l'objet de requête de la session pour extraire des données de la base de données :

from models import User
from sqlalchemy import SQLAlchemy

db = SQLAlchemy()

# Query the User table
users = db.session.query(User).all()

# Iterate over the records and print them to the console
for user in users:
    print(user.username)

 

Cas d'utilisation de SQLAlchemy

SQLAlchemy est largement utilisé dans divers domaines, dont les suivants :

• Développement Web: De nombreux frameworks web, tels que Flask et Django, s'intègrent parfaitement à SQLAlchemy pour la gestion des bases de données.
• Analyse des données et rapports: SQLAlchemy aide les scientifiques et les analystes de données à interagir avec les bases de données relationnelles lors de l'analyse des données.
• Applications Enterprise: Il s'agit d'un choix privilégié pour la création d'applications d'entreprise robustes, évolutives et faciles à maintenir.
• Microservices: SQLAlchemy prend en charge l'architecture des microservices en permettant à chaque service d'interagir avec sa base de données.

 

Les avantages de l'utilisation de SQLAlchemy

SQLAlchemy présente de nombreux avantages, dont certains sont énumérés ci-dessous :

• Productivité accrue:  SQLAlchemy peut aider les développeurs à être plus productifs en fournissant une abstraction de haut niveau pour l'accès aux bases de données. Elle permet aux développeurs de se concentrer sur l'écriture de code d'application plutôt que de s'inquiéter de la syntaxe SQL sous-jacente.
• Erreurs réduites:  SQLAlchemy peut nous aider à réduire les erreurs en fournissant un système de type pour l'accès à la base de données. Cela nous permet de nous assurer que les développeurs utilisent les bons types de données et ne commettent pas d'erreurs.
• Amélioration de la maintenabilité: SQLAlchemy permet d'améliorer la maintenabilité du code en facilitant la modification du schéma de la base de données. C'est possible parce que le code SQLAlchemy n'est pas couplé étroitement au schéma de la base de données sous-jacente.
• Portabilité: Le code SQLAlchemy est portable dans n'importe quelle base de données compatible avec SQLAlchemy. Il simplifie la migration des applications vers différentes bases de données.

Conclusion

SQLAlchemy permet aux développeurs Python de travailler avec des bases de données relationnelles d'une manière plus pythonique et plus efficace. Ses capacités ORM, son langage d'expression SQL, son pool de connexions et son support multiplateforme en font un outil précieux pour diverses applications. Peu importe que vous soyez un développeur débutant ou expérimenté, SQLAlchemy peut rationaliser vos tâches relatives aux bases de données et améliorer votre productivité.

Dans mon prochain article, nous utiliserons SQLAlchemy et InterSystems Caché pour démontrer les opérations CRUD.

Merci d'avoir lu !