Débuter avec sqlalchemy

Bonjour le monde! (Noyau SQLAlchemy)

Cet exemple montre comment créer une table, insérer des données et effectuer une sélection dans la base de données à l’aide de SQLAlchemy Core. Pour plus d’informations sur l’[ORM SQLAlchemy, voir ici][1].

Tout d’abord, nous devrons nous [connecter][2] à notre base de données.

from sqlalchemy import create_engine

engine = create_engine('sqlite://')

Le moteur est le point de départ de toute application SQLAlchemy. C’est une “base d’accueil” pour la base de données réelle et sa DBAPI, livrée à une application SQLAlchemy via un pool de connexions et un dialecte, qui décrit comment parler à un type spécifique de combinaison base de données/DBAPI. Le moteur fait référence à la fois à un dialecte et à un pool de connexions, qui interprètent ensemble les fonctions du module DBAPI ainsi que le comportement de la base de données.

Après avoir créé notre moteur, nous devons [définir et créer nos tableaux][3].

from sqlalchemy import Column, Integer, Text, MetaData, Table

metadata = MetaData()
messages = Table(
    'messages', metadata,
    Column('id', Integer, primary_key=True),
    Column('message', Text),
)

messages.create(bind=engine)

Pour plus d’explications sur l’objet MetaData, consultez la documentation ci-dessous :

Une collection d’objets Table et leurs objets enfants associés sont appelés métadonnées de base de données

Nous définissons nos tables dans un catalogue appelé MetaData, en utilisant la construction Table, qui ressemble aux instructions SQL CREATE TABLE habituelles.

Maintenant que nos tables sont définies et créées, nous pouvons commencer à insérer des données ! L’insertion comporte deux étapes. Composer la construction [insert][4] et [exécuter][5] la requête finale.

insert_message = messages.insert().values(message='Hello, World!')
engine.execute(insert_message)

Maintenant que nous avons des données, nous pouvons utiliser la fonction [select][6] pour interroger nos données. Les objets Column sont disponibles en tant qu’attributs nommés de l’attribut c sur l’objet Table, ce qui facilite la sélection directe des colonnes. L’exécution de cette instruction select renvoie un objet ResultProxy qui a accès à quelques méthodes, [fetchone()][7], [fetchall()][8] et [fetchmany()][7], qui renvoient toutes un certain nombre de lignes de base de données interrogées dans notre instruction select.

from sqlalchemy import select
stmt = select([messages.c.message]) 
message, = engine.execute(stmt).fetchone()
print(message)

Hello, World!

Et c’est tout! Voir le [Tutoriel sur les expressions SQL de SQLAlchemy][9] pour plus d’exemples et d’informations.

[1] : http://docs.sqlalchemy.org/en/latest/orm/tutorial.html [2] : http://docs.sqlalchemy.org/en/latest/core/tutorial.html#connecting [3] : http://docs.sqlalchemy.org/en/latest/core/tutorial.html#define-and-create-tables [4] : http://docs.sqlalchemy.org/en/latest/core/tutorial.html#insert-expressions [5] : http://docs.sqlalchemy.org/en/latest/core/tutorial.html#executing [6] : http://docs.sqlalchemy.org/en/latest/core/tutorial.html#selecting [7] : http://docs.sqlalchemy.org/en/latest/core/connections.html#sqlalchemy.engine.ResultProxy.fetchone [8] : http://docs.sqlalchemy.org/en/latest/core/connections.html#sqlalchemy.engine.ResultProxy.fetchall [9] : http://docs.sqlalchemy.org/en/latest/core/tutorial.html

Bonjour le monde! (ORM SQLAlchimie)

Cet exemple montre comment créer une table, insérer des données et effectuer une sélection dans la base de données à l’aide de SQLAlchemy ORM. Pour plus d’informations sur : [SQLAlchemy Core, voir ici][1].

Tout d’abord, nous devons nous connecter à notre base de données, ce qui est identique à la façon dont nous nous connecterions en utilisant SQLAlchemy Core (Core).

from sqlalchemy import create_engine

engine = create_engine('sqlite://')

Après avoir connecté et créé notre moteur, nous devons définir et créer nos tables. C’est là que le langage ORM SQLAlchemy commence à différer considérablement de Core. Dans ORM, le processus de création et de définition de table commence par définir les tables et les classes que nous utiliserons pour mapper à ces tables. Ce processus se fait en une seule étape dans ORM, que SQLAlchemy appelle le système [Declarative][2].

from sqlalchemy.ext.declarative import declarative_base
Base = declarative_base()

Maintenant que notre mappeur de base est déclaré, nous pouvons en sous-classer pour construire nos [mappages déclaratifs] [3], ou “modèles”.

from sqlalchemy import Column, Integer, String

class Message(Base):
    __tablename__ = 'messages'
    
    id = Column(Integer, primary_key=True)
    message = Column(String)

En utilisant la classe de base déclarative, nous finissons par créer un objet Table et Mapper. À partir de la documentation :

L’objet Table fait partie d’une plus grande collection connue sous le nom de MetaData. Lors de l’utilisation de Declarative, cet objet est disponible à l’aide de l’attribut .metadata de notre classe de base déclarative.

Dans cet esprit, pour créer toutes les tables qui n’existent pas encore, nous pouvons appeler la commande ci-dessous, qui utilise le registre MetaData de SQLAlchemy Core.

Base.metadata.create_all(engine)

Maintenant que nos tables sont mappées et créées, nous pouvons insérer des données ! L’insertion se fait par la [création d’instances de mappeur][4].

message = Message(message="Hello World!")
message.message # 'Hello World!

À ce stade, tout ce que nous avons est une instance de message au niveau du niveau d’abstraction ORM, mais rien n’a encore été enregistré dans la base de données. Pour ce faire, nous devons d’abord créer une [session][5].

from sqlalchemy.orm import sessionmaker

Session = sessionmaker(bind=engine)
session = Session()

Cet objet de session est notre gestionnaire de base de données. Selon les docs SQLAlchemy :

il récupère une connexion à partir d’un pool de connexions gérées par le moteur et la conserve jusqu’à ce que nous validions toutes les modifications et/ou fermions l’objet de session.

Maintenant que nous avons notre session, nous pouvons [ajouter][6] notre nouveau message à la session et valider nos modifications dans la base de données.

session.add(message)
session.commit()

Maintenant que nous avons des données, nous pouvons tirer parti du langage de requête ORM pour extraire nos données.

query = session.query(Message)
instance = query.first()
print (instance.message) # Hello World!

Mais ce n’est que le début ! Il y a beaucoup plus de fonctionnalités qui peuvent être utilisées pour composer des requêtes, comme filter, order_by, et bien plus encore. Voir le [SQLAlchemy ORM Tutorial][6] pour plus d’exemples et d’informations.

[1] : http://docs.sqlalchemy.org/en/latest/core/tutorial.html [2] : http://docs.sqlalchemy.org/en/latest/orm/extensions/declarative/index.html [3] : http://docs.sqlalchemy.org/en/latest/orm/tutorial.html#declare-a-mapping [4] : http://docs.sqlalchemy.org/en/latest/orm/tutorial.html#create-an-instance-of-the-mapped-class [5] : http://docs.sqlalchemy.org/en/latest/orm/tutorial.html#creating-a-session [6] : http://docs.sqlalchemy.org/en/latest/orm/tutorial.html#adding-and-updating-objects

Installation ou configuration

pip install sqlalchemy

Pour les applications les plus courantes, en particulier les applications Web, il est généralement recommandé aux débutants d’envisager d’utiliser une bibliothèque supplémentaire, telle que flask-sqlalchemy.

pip install flask-sqlalchemy