[PYTHON] Utilisation de base de SQL Alchemy

Qu'est-ce que SQL Alchemy?

SQLAlchemy est l'un des ORMs souvent utilisés en Python. ORM est un Object Relational Mapper. En termes simples, il a une correspondance biunivoque entre les tables et les classes, et permet aux données d'être acquises et modifiées via les méthodes de cette classe.

Quels sont les avantages de l'ORM?

1. Absorbe la différence entre les différents DB

Comme le même code source peut être utilisé quel que soit le type de DB, il n'est pas nécessaire de réécrire le code lors de l'utilisation de plusieurs DB ensemble ou lors du changement de DB.

2. Vous n'avez pas besoin d'écrire du SQL

SQL est utilisé pour faire fonctionner des bases de données telles que MySQL, SQLite et PostgreSQL, mais SQLAlchemy vous permet d'exploiter des bases de données dans "Pythonic" sans écrire directement de SQL.

Comment utiliser SQLAlchemy

En tant que flux simple, définissez quelle base de données et comment vous connecter. (Celui qui contient les paramètres s'appelle le moteur) Après cela, le mappage est effectué et une session est créée. Ensuite, utilisez cette session pour effectuer des opérations de base de données.

1. Créez un moteur de base de données

from sqlalchemy import create_engine
engine=create_engine("{dialect}+{driver}://{username}:{password}@{host}:{port}/{database}?charset={charset_type})

Écrivez comme suit pour créer une instance du moteur. L'explication de chaque élément est indiquée dans le tableau ci-dessous.

Par exemple, cela ressemble à ce qui suit. (Le pilote, le port et le type de jeu de caractères ne sont pas spécifiés.)

engine=create_engine("mysql://scott:tiger@localhost/foo")

2. Créez une classe de modèle (écrivez une définition de table)

Commencez par créer une classe de base de modèle.

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

Ensuite, en étendant cette classe de base, elle devient une classe modèle qui peut être gérée par ORM. Par exemple, écrivez la classe comme suit. Il est également possible d'ajouter des méthodes lors de la définition d'une classe de modèle.

from sqlalchemy.schema import Column
from sqlalchemy.types import Integer, String
class User(Base):
    __tablename__="user" #Spécifiez le nom de la table
    user_id=Column(Integer, primary_key=True)
    first_name=Column(String(255))
    last_name=Column(String(255))
    age=Column(Integer)
    def full_name(self):#Méthode pour renvoyer le nom complet
        return "{self.first_name} {self.last_name}"

La classe définie ci-dessus est une carte du tableau présenté dans le tableau ci-dessous.

Pour créer cette table dans le DB

Base.metadata.create_all(engine)

Cela créera un lot de groupes de tables héritant de Base. Les détails de la définition de la table sont les suivants. Définition de table dans SQL Alchemy

Qu'est-ce que les métadonnées

Le mot métadonnées est sorti dans le code ci-dessus, mais les métadonnées sont un objet qui contient diverses informations dans la base de données. En utilisant ces métadonnées, vous pouvez également importer des définitions de table à partir d'une base de données existante.

3. Créez une session

SQLAlchemy exécute les requêtes via des sessions. En premier lieu, une session est une série d'unités allant de l'établissement d'une connexion à sa déconnexion. (Image de quelque chose comme une chaîne qui relie le code DB et Python)

Créer une session Créez une classe avec Sessionmaker. (Si le moteur à utiliser est constant, spécifiez-le à ce moment)

from sqlalchemy.orm import sessionmaker
SessionClass=sessionmaker(engine) #Créer une classe pour créer une session
session=SessionClass()

La manipulation détaillée est la suivante. Comment gérer une session dans SQL Alchemy

4. Effectuer le traitement CRUD

CRUD est un nom collectif pour les fonctions suivantes. · Créer · Lis · Mise à jour ・ Détruire

Notez que la base de données ne sera mise à jour que si vous fermez la session ou commit () explicitement.

INSERT Si vous ajoutez () un nouvel objet à la session, il devient une cible INSERT.

user_a=User(first_name="first_a", last_name="last_a", age=20)
session.add(user_a)
session.commit()

SELECT Utilisez une requête pour récupérer des données de la table.

users=session.query(User).all() #Renvoie tous les enregistrements de la table utilisateur sous forme de tableau contenant des classes
user=session.query(User).first() #Renvoie le premier enregistrement de la table utilisateur en tant que classe

Pour plus de détails, consultez les références.

UPDATE Si vous modifiez l'objet récupéré de la session, il sera UPDATEd.

user_a=session.query(User).get(1) #Utilisateur ajouté ci-dessus_id=1 enregistrement
user_a.age=10
session.commit()

DELETE Si vous supprimez () un objet récupéré d'une session, il sera soumis à DELETE.

user_a=session.query(User).get(1)
session.delete(user_a)
session.commit()

Vous pouvez également supprimer ceux qui correspondent aux conditions de recherche.

session.query(User).filter(User.user_id=1).delete()
session.commit()

5. Lors de l'utilisation d'une table existante

Dans 3, vous avez créé une classe qui mappe une nouvelle table, mais vous souhaiterez peut-être créer une classe qui mappe une table existante. La procédure consiste à transmettre des métadonnées à la classe de base, à faire correspondre \ _ \ _ nom_table__ avec le nom de table existant et à définir le chargement automatique sur True. La façon de transmettre des métadonnées à la classe de base consiste à transmettre le moteur lors de la création de la classe de base.

Base=declarative_base(bind=engine)

Ou comment transmettre des métadonnées lors de la création d'une classe de base

from sqlalchemy.schema import MetaData
meta=MetaData(engine)
meta.reflect() #Obtenez des métadonnées, des méta=MetaData(engine, reflect=True)Pareil que
Base=declarative_base(metadata=meta) 

Ou comment le donner après avoir créé la classe de base

Base=declarative_base()
Base.metadata.bind=engine 

Il y a. Par exemple, s'il existe une table avec le nom de table visitant \ _user.

Base=declarative_base(bind=engine)
class Exisiting_user(Base): #Tout nom de classe est ok
    __tablename__="exisiting_user" 
    __table_args__={"autoload": True}

Et c'est suffisant.

Les références

Cet article a été rédigé en référence aux informations suivantes. ・ Document officiel ・ PlaySQLAlchemy: Introduction à SQLAlchemy ・ Je souhaite profiter de la définition de base de données avec SQL Alchemy ・ [Python ORM] Résumé des requêtes SQL de base avec SQL Alchemy

• À propos de la génération du modèle à partir de la base de données existante par automap de sqlalchemy