Résumé de SQLAlchemy, la boîte à outils SQL pour python Les questions, suggestions et demandes de modification sont les bienvenues. Je vous remercie.
Outil ORM (Object Relational Mapper) utilisé lors de l'utilisation de DB en Python
Facile à construire avec Docker
docker-compose.yml
version: "3"
services:
db:
image: postgres:11.7
container_name: sqlalchemy-db
ports:
- 5432:5432
environment:
- POSTGRES_USER=postgres
- POSTGRES_PASSWORD=postgres
- POSTGRES_DB=sqlalchemy
app:
image: python:3.8.2-slim
container_name: sqlalchemy-app
volumes:
- ./src:/usr/src
environment:
- PYTHONPATH=${PYTHONPATH}:/usr/src
tty: true
Installez ** SQLAlchemy ** et ** psycopg2-binary **
Installer des packages python
pip install SQLAlchemy psycopg2-binary
root@4e7436ca992b:/usr/src# pip install SQLAlchemy psycopg2-binary
Collecting SQLAlchemy
Downloading SQLAlchemy-1.3.16-cp38-cp38-manylinux2010_x86_64.whl (1.2 MB)
|████████████████████████████████| 1.2 MB 8.3 MB/s
Collecting psycopg2-binary
Downloading psycopg2_binary-2.8.5-cp38-cp38-manylinux1_x86_64.whl (3.0 MB)
|████████████████████████████████| 3.0 MB 60.6 MB/s
Installing collected packages: SQLAlchemy, psycopg2-binary
Successfully installed SQLAlchemy-1.3.16 psycopg2-binary-2.8.5
Préparez SQLAlchemy à partir d'ici Si vous complétez facilement l'image, ce sera comme suit
Engine est un pont qui relie Python et DB (PostgresSQL) La session est comme une boîte qui contient des instructions (requête) à exécuter par DB à l'aide d'Engine. Models est une classe à associer aux informations de table définies dans DB De plus, chaque modèle hérite de la classe définie dans ** declareeative_base **.
Utilisez ** create_engine () ** pour créer le moteur Utilisez ** sessionmaker () ** pour créer une session
setting.py
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from sqlalchemy.ext.declarative import declarative_base
#Créer un moteur
Engine = create_engine(
"postgresql://postgres:postgres@sqlalchemy-db:5432/sqlalchemy",
encoding="utf-8",
echo=False
)
#Créer une session
session = sessionmaker(
autocommit=False,
autoflush=False,
bind=Engine
)
BaseModel = declarative_base()
Définir UserModel Définissez uniquement les colonnes id et name ici
model.py
from sqlalchemy import Column, String, Integer
from setting import BaseModel
class UserModel(BaseModel):
"""
UserModel
"""
__tablename__ = 'users'
id = Column(Integer, primary_key=True, autoincrement=True)
name = Column(String(255), nullable=False)
def __init__(self, name, created_at=None, updated_at=None):
self.name = name
Si BaseModel est hérité par tous les modèles, les tables peuvent être créées et supprimées à l'aide des ** métadonnées ** de BaseModel. Ce que vous écrivez souvent dans SetUp et TearDown, comme lors de l'écriture de tests unitaires
Créer et supprimer des tables
from setting import Engine
from model import BaseModel
#Créer une table
BaseModel.metadata.create_all(bind=Engine)
#Supprimer la table
BaseModel.metadata.drop_all(Engine)
L'instruction INSERT utilise ** session.add () **
** SQLAlchemyError ** intercepte toutes les erreurs qui se produisent dans SQLAlchemy
Insérer un enregistrement (instruction INSERT)
from setting import Session, Engine
from model import UserModel, BaseModel
from sqlalchemy.exc import SQLAlchemyError
def model_insert():
try:
session = Session()
user = UserModel(name='Maso')
session.add(user)
session.commit()
except SQLAlchemyError:
session.rollback()
finally:
session.close()
if __name__ == "__main__":
#Créer une table
BaseModel.metadata.create_all(bind=Engine)
model_insert()
#Supprimer la table
BaseModel.metadata.drop_all(Engine)
Obtenir des enregistrements en utilisant ** query () ** dans la session
Il y a beaucoup d'autres choses (comme la jonction de tables), il peut donc être judicieux de rechercher dans le didacticiel ci-dessous. Object Relational Tutorial — SQLAlchemy 1.3 Documentation
Obtenir un enregistrement (instruction SELECT)
def model_select():
try:
session = Session()
#Obtenez un seul enregistrement
user = session.query(UserModel).first()
#Obtenez tous les enregistrements
user = session.query(UserModel).all()
#Obtention en spécifiant des conditions (clause WHERE)
user = session.query(UserModel).\
filter(UserModel.name == 'Maso').\
all()
except SQLAlchemyError:
pass
finally:
session.close()
Mise à jour en réécrivant les propriétés de l'enregistrement acquis en session et en validant
Enregistrer la mise à jour (instruction UPDATE)
def model_update():
try:
session = Session()
#Obtention en spécifiant des conditions (clause WHERE)
user = session.query(UserModel).\
filter(UserModel.name == 'Maso').\
first()
user.name = 'Tarao'
session.commit()
except SQLAlchemyError:
session.rollback()
finally:
session.close()
Il est supprimé lorsque ** delete () ** est exécuté sur l'enregistrement acquis par session.
Enregistrer la mise à jour (instruction UPDATE)
def model_delete():
try:
session = Session()
session.query(UserModel).\
filter(UserModel.name == 'Tarao').\
.delete()
session.commit()
except SQLAlchemyError:
session.rollback()
finally:
session.close()
main.py
from setting import Session, Engine
from model import UserModel, BaseModel
from sqlalchemy.exc import SQLAlchemyError
def model_insert():
try:
session = Session()
user = UserModel(name='Maso')
session.add(user)
session.commit()
except SQLAlchemyError:
session.rollback()
finally:
session.close()
def model_select():
try:
session = Session()
#Obtenez un seul enregistrement
user = session.query(UserModel).first()
#Obtenez tous les enregistrements
user = session.query(UserModel).all()
#Obtention en spécifiant des conditions (clause WHERE)
user = session.query(UserModel).\
filter(UserModel.name == 'Maso').\
all()
except SQLAlchemyError:
pass
finally:
session.close()
def model_update():
try:
session = Session()
#Obtention en spécifiant des conditions (clause WHERE)
user = session.query(UserModel).\
filter(UserModel.name == 'Maso').\
first()
user.name = 'Tarao'
session.commit()
except SQLAlchemyError:
session.rollback()
finally:
session.close()
def model_delete():
try:
session = Session()
#Obtention en spécifiant des conditions (clause WHERE)
session.query(UserModel).\
filter(UserModel.name == 'Tarao').\
.delete()
session.commit()
except SQLAlchemyError:
session.rollback()
finally:
session.close()
if __name__ == "__main__":
#Créer une table
BaseModel.metadata.create_all(bind=Engine)
model_insert()
model_select()
model_update()
model_delete()
#Supprimer la table
BaseModel.metadata.drop_all(Engine)
Tips
Par exemple, la date de création (created_at) et la date de mise à jour (updated_at) Il est difficile d'écrire dans la définition du modèle à chaque fois, il est donc pratique d'utiliser ** @ declare_attr ** Passer une classe avec des colonnes créées à l'aide de @declared_attr lors de la création d'un BaseModel créera une colonne commune
Créer une colonne commune
class Base(object):
@declared_attr
def created_at(cls):
return Column(DateTime, default=datetime.now, nullable=False)
@declared_attr
def updated_at(cls):
return Column(DateTime, default=datetime.now, nullable=False)
BaseModel = declarative_base(cls=Base)
Facile à créer et à supprimer à l'aide de SQLAlchemy-Utils - documentation SQLAlchemy-Utils 0.33.9 Image à utiliser au début du test ou lors du lancement de l'application
Vérification et création de l'existence d'une base de données
from sqlalchemy import create_engine
from sqlalchemy_utils import database_exists, create_database, drop_database
engine = create_engine("postgresql://postgres:postgres@sqlalchemy-db:5432/sqlalchemy")
if not database_exists(engine.url):
#Création de DB
create_database(engine.url)
#Supprimer la base de données
drop_database(engine.url)
Si vous utilisez postgres etc. et que vous souhaitez créer un schéma, utilisez CreateSchema et DropSchema
Créer / supprimer un schéma
from sqlalchemy.schema import CreateSchema, DropSchema
from sqlalchemy import create_engine
engine = create_engine("postgresql://postgres:postgres@sqlalchemy-db:5432/sqlalchemy")
schema_name = 'test'
#Vérification de l'existence du schéma
if not engine.dialect.has_schema(Engine, schema_name):
#Créer un schéma
engine.execute(CreateSchema(schema_name))
#Supprimer le schéma
Engine.execute(DropSchema(schema_name))
Recommended Posts