J'ai essayé de résumer brièvement SQLAlchemy (il y a aussi des CONSEILS)

Cible

Résumé de SQLAlchemy, la boîte à outils SQL pour python Les questions, suggestions et demandes de modification sont les bienvenues. Je vous remercie.

Qu'est-ce que SQLAlchemy? ??

Outil ORM (Object Relational Mapper) utilisé lors de l'utilisation de DB en Python

Préparation environnementale

Créer un environnement avec Docker

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

Installation du package

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éparation de SQLAlchemy

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 **.

Création d'un moteur et d'une session

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()

Créer un modèle

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

Utilisation de SQLAlchemy

Créer et supprimer des tables à l'aide de BaseModel

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)

Insérer un enregistrement (instruction INSERT)

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 un enregistrement (instruction SELECT)

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()

Enregistrer la mise à jour (instruction UPDATE)

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()

Supprimer l'enregistrement (instruction DELETE)

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()

Résumé du code source

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

Je voudrais avoir une colonne commune. ??

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)

Est-il possible de créer un DB? ??

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)

Comment créer un schéma? ??

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

J'ai essayé de résumer brièvement SQLAlchemy (il y a aussi des CONSEILS)
J'ai essayé de résumer SparseMatrix
J'ai essayé de résumer la gestion des exceptions Python
J'ai essayé de résumer la commande umask
Entrée standard Python3 que j'ai essayé de résumer
J'ai essayé de résumer les modules d'Ansible - l'édition Linux
LeetCode j'ai essayé de résumer les plus simples
J'ai essayé de déboguer.
J'ai essayé de résumer comment utiliser matplotlib de python
J'ai essayé de résumer la forme de base de GPLVM
J'ai essayé de résumer quatre méthodes d'optimisation de réseau neuronal
J'ai essayé de résumer comment utiliser les pandas de python
Je veux dire qu'il y a un prétraitement des données ~
J'ai essayé de résumer les opérations de chaîne de Python
[Première API COTOHA] J'ai essayé de résumer l'ancienne histoire
J'ai essayé d'apprendre PredNet
J'ai essayé d'organiser SVM.
J'ai essayé d'implémenter PCANet
J'ai essayé de résumer le code souvent utilisé dans Pandas
J'ai essayé de réintroduire Linux
J'ai essayé de résumer les commandes souvent utilisées en entreprise
jupyter je l'ai touché
J'ai essayé d'implémenter StarGAN (1)
J'ai essayé de résumer comment utiliser à nouveau le référentiel EPEL
J'ai essayé de créer un article dans Wiki.js avec SQL Alchemy
[Linux] J'ai essayé de résumer les commandes de confirmation des ressources
J'ai essayé d'utiliser l'API COTOHA (il y a aussi du code sur GitHub)
J'ai essayé de résumer ce qui était sorti avec Qiita avec Word cloud
J'ai essayé de savoir si ReDoS est possible avec Python
J'ai essayé de résumer les commandes utilisées par les ingénieurs débutants aujourd'hui
J'ai essayé de résumer les remarques de tout le monde sur le slack avec wordcloud (Python)
J'ai essayé de résumer la méthode de mise en œuvre fréquemment utilisée de pytest-mock
J'ai essayé d'implémenter Deep VQE
J'ai essayé de créer l'API Quip
J'ai essayé de toucher Python (installation)
J'ai essayé de mettre en place une validation contradictoire
J'ai essayé d'expliquer l'ensemble de données de Pytorch
J'ai essayé l'authentification vocale Watson (Speech to Text)
J'ai touché l'API de Tesla
J'ai essayé de m'organiser à propos de MCMC.
J'ai essayé d'implémenter Realness GAN
J'ai essayé de déplacer le ballon
J'ai essayé d'estimer la section.
J'ai essayé de résumer jusqu'à ce que je quitte la banque et devienne ingénieur
J'ai essayé de mettre en œuvre un apprentissage en profondeur qui n'est pas profond avec uniquement NumPy
J'ai essayé d'analyser les émotions si Hinatazaka 46 est vraiment une "aura heureuse"
J'ai essayé de résumer Cpaw Level1 & Level2 Write Up d'une manière facile à comprendre
J'ai essayé de résumer diverses phrases à l'aide de l'API de synthèse automatique "summpy"
J'ai essayé de résumer la manière logique de penser l'orientation objet.
J'ai essayé de résumer les commandes Linux utilisées par les ingénieurs débutants aujourd'hui - Partie 1-
J'ai essayé de savoir ce que je pouvais faire car le tranchage est pratique
J'ai essayé d'implémenter PLSA en Python
J'ai essayé d'utiliser Azure Speech to Text.
J'ai essayé d'implémenter Autoencoder avec TensorFlow
J'ai essayé d'implémenter la permutation en Python
J'ai essayé de créer un linebot (préparation)
J'ai essayé de visualiser AutoEncoder avec TensorFlow
J'ai essayé de reconnaître le mot de réveil
J'ai essayé de commencer avec Hy