J'étais accro parce que je n'avais pas beaucoup d'informations, alors je vais prendre une note.
Cette fois, je vais montrer un exemple d'INNER JOIN en utilisant l'exemple de table fourni par MySQL.
MySQL :: MySQL Documentation: Other MySQL Documentation Obtenez les exemples de données à partir du lien à droite de la base de données de ménagerie sur la page ci-dessus et chargez-les.
La méthode de chargement sur MySQL est omise. Le contenu des exemples de données est constitué de deux tableaux contenant chacun 10 et 9 enregistrements.
mysql> show tables;
+---------------------+
| Tables_in_menagerie |
+---------------------+
| event |
| pet |
+---------------------+
2 rows in set (0.01 sec)
mysql> select * FROM event;
+----------+------------+----------+-----------------------------+
| name | date | type | remark |
+----------+------------+----------+-----------------------------+
| Fluffy | 1995-05-15 | litter | 4 kittens, 3 female, 1 male |
| Buffy | 1993-06-23 | litter | 5 puppies, 2 female, 3 male |
| Buffy | 1994-06-19 | litter | 3 puppies, 3 female |
| Chirpy | 1999-03-21 | vet | needed beak straightened |
| Slim | 1997-08-03 | vet | broken rib |
| Bowser | 1991-10-12 | kennel | NULL |
| Fang | 1991-10-12 | kennel | NULL |
| Fang | 1998-08-28 | birthday | Gave him a new chew toy |
| Claws | 1998-03-17 | birthday | Gave him a new flea collar |
| Whistler | 1998-12-09 | birthday | First birthday |
+----------+------------+----------+-----------------------------+
10 rows in set (0.00 sec)
mysql> select * FROM pet;
+----------+--------+---------+------+------------+------------+
| name | owner | species | sex | birth | death |
+----------+--------+---------+------+------------+------------+
| Fluffy | Harold | cat | f | 1993-02-04 | NULL |
| Claws | Gwen | cat | m | 1994-03-17 | NULL |
| Buffy | Harold | dog | f | 1989-05-13 | NULL |
| Fang | Benny | dog | m | 1990-08-27 | NULL |
| Bowser | Diane | dog | m | 1979-08-31 | 1995-07-29 |
| Chirpy | Gwen | bird | f | 1998-09-11 | NULL |
| Whistler | Gwen | bird | NULL | 1997-12-09 | NULL |
| Slim | Benny | snake | m | 1996-04-29 | NULL |
| Puffball | Diane | hamster | f | 1999-03-30 | NULL |
+----------+--------+---------+------+------------+------------+
9 rows in set (0.00 sec)
L'histoire de SQL Alchemy d'ici. J'ai souvent voulu faire ce genre de connexion. (Au fait, `` litière '' signifie donner naissance à un animal)
mysql> SELECT event.name, event.date, event.type, event.remark, pet.species
FROM event INNER JOIN pet ON event.name = pet.name
WHERE event.type ='litter';
+--------+------------+--------+-----------------------------+---------+
| name | date | type | remark | species |
+--------+------------+--------+-----------------------------+---------+
| Fluffy | 1995-05-15 | litter | 4 kittens, 3 female, 1 male | cat |
| Buffy | 1993-06-23 | litter | 5 puppies, 2 female, 3 male | dog |
| Buffy | 1994-06-19 | litter | 3 puppies, 3 female | dog |
+--------+------------+--------+-----------------------------+---------+
3 rows in set (0.00 sec)
Comment exprimer cela dans SQL Alchemy est la suivante.
#Créer une instance de chaque table
events = Table('event', metadata, autoload=True)
pets = Table('pet', metadata, autoload=True)
#:Créez une liste de colonnes que vous souhaitez obtenir
columns = [events, pets.c.species]
#: join()Spécifiez la table et la condition avec lesquelles vous souhaitez joindre select()Appel
q = join(events, pets, events.c.name == pets.c.name) \
.select() \
.where(events.c.type == 'litter')
#:Enfin avec_only_columns()Passez la liste des colonnes auxquelles vous souhaitez accéder
q = q.with_only_columns(columns)
with_only_columns () est utilisé pour affiner les champs à obtenir.
Ensuite, créez la requête suivante comme exemple de requête qui utilise count () à l'aide de GROUP BY.
mysql> SELECT event.name, count(event.name) AS litter_count
FROM event INNER JOIN pet ON event.name = pet.name
WHERE event.type = 'litter' GROUP BY event.name;
+--------+--------------+
| name | litter_count |
+--------+--------------+
| Buffy | 2 |
| Fluffy | 1 |
+--------+--------------+
2 rows in set (0.00 sec)
#: func.count()Spécifiez les colonnes à agréger avec
#: AS litter_nombre d'étiquettes('litter_count')Spécifié par
columns = [events.c.name, func.count(events.c.name).label('litter_count')]
q = join(events, pets, events.c.name == pets.c.name) \
.select() \
.where(events.c.type == 'litter') \
.group_by(events.c.name) # <=Ajouter une ligne à la requête précédente
q = q.with_only_columns(columns)
Le code plus court serait:
q = select(events.c.name == pets.c.name) \
.where(events.c.type == 'litter') \
.group_by(events.c.name)
q = q.with_only_columns(columns)
La condition de jointure a été déplacée dans select () sans join ().
Avec SQLAlchemy, vous pouvez écrire des requêtes en utilisant INNER JOIN, GROUP BY et COUNT () avec juste autant de code.
C'est une histoire difficile, mais au moment où je suis arrivé ici, j'ai lu divers documents et finalement fait cette requête. SQLAlchemy est si riche en fonctionnalités que vous devriez lire la documentation une fois avant de l'utiliser sérieusement. Je n'avais pas beaucoup d'informations en japonais, j'ai donc lu et étudié Stack Overflow et d'autres sites en anglais. Si vous utilisez Python, c'est difficile si vous ne parlez pas anglais. Pour Ruby, il y a beaucoup d'informations japonaises grâce à Rails, mais Python n'est pas populaire au Japon, donc j'ai l'impression qu'il y a peu de savoir-faire.
Je pense qu'il faudra beaucoup de temps pour comprendre une fois, mais une fois que je l'ai compris, je me suis rendu compte que c'est une bibliothèque assez puissante. J'étudie toujours, donc je ne pense pas que le style d'écriture ci-dessus soit toujours le meilleur, et il devrait y avoir un meilleur style d'écriture qui soit plus lisible.
J'ai vu de nombreux documents que SQLAlchemy utilise comme ORM, mais j'aime utiliser SQLAlchemy comme générateur de requêtes pour les instructions SELECT.
Plutôt que de créer une bibliothèque de votre propre générateur de requêtes dans un projet et de le rendre impossible J'ai trouvé beaucoup plus facile pour tout le monde d'étudier et d'utiliser SQL Alchemy.
sample.py
#!/usr/bin/env python2.7
# -*- coding:utf-8 -*-
from sqlalchemy import create_engine, MetaData, Table
from sqlalchemy.sql import select, join, func
from pprint import pprint
config = {
'user': 'user',
'passwd':'password',
'host': 'localhost',
'port': 3306,
'database': 'menagerie',
}
dsn_fmt = 'mysql+pymysql://%(user)s:%(passwd)s@%(host)s:%(port)d/%(database)s'
dsn = dsn_fmt % config
engine = create_engine(dsn, echo=True)
metadata = MetaData(bind=engine)
events = Table('event', metadata, autoload=True)
pets = Table('pet', metadata, autoload=True)
if __name__ == '__main__':
#: part1
columns = [events, pets.c.species]
q = join(events, pets, events.c.name == pets.c.name) \
.select().where(events.c.type == 'litter')
q = q.with_only_columns(columns)
print q
for row in q.execute():
pprint(dict(row))
#: part2
columns = [events.c.name, func.count(events.c.name).label('litter_count')]
q = join(events, pets, events.c.name == pets.c.name) \
.select() \
.where(events.c.type == 'litter') \
.group_by(events.c.name)
q = q.with_only_columns(columns)
print q
for row in q.execute():
pprint(dict(row))
#: part2 another version
q = select(events.c.name == pets.c.name) \
.where(events.c.type == 'litter') \
.group_by(events.c.name)
q = q.with_only_columns(columns)
print q
for row in q.execute():
pprint(dict(row))
Recommended Posts