Ich war süchtig danach, weil ich nicht viele Informationen hatte, also mache ich mir eine Notiz.
Dieses Mal werde ich ein Beispiel für INNER JOIN anhand der von MySQL bereitgestellten Beispieltabelle zeigen.
MySQL :: MySQL Documentation: Other MySQL Documentation Rufen Sie die Beispieldaten über den Link rechts neben der Menagerie-Datenbank auf der obigen Seite ab und laden Sie sie.
Die Lademethode für MySQL entfällt. Der Inhalt der Beispieldaten besteht aus zwei Tabellen mit jeweils 10 und 9 Datensätzen.
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)
Die Geschichte von SQL Alchemy von hier. Ich wollte oft diese Art von Verbindung herstellen. (Wurf bedeutet übrigens, ein Tier zur Welt zu bringen)
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)
So drücken Sie dies in SQL Alchemy aus:
#Erstellen Sie eine Instanz jeder Tabelle
events = Table('event', metadata, autoload=True)
pets = Table('pet', metadata, autoload=True)
#:Erstellen Sie eine Liste der Spalten, die Sie abrufen möchten
columns = [events, pets.c.species]
#: join()Geben Sie die Tabelle und die Bedingung an, der Sie mit select beitreten möchten()Anruf
q = join(events, pets, events.c.name == pets.c.name) \
.select() \
.where(events.c.type == 'litter')
#:Endlich mit_only_columns()Übergeben Sie die Liste der Spalten, zu denen Sie gelangen möchten
q = q.with_only_columns(columns)
with_only_columns () wird verwendet, um die abzurufenden Felder einzugrenzen.
Erstellen Sie als Nächstes die folgende Abfrage als Beispiel für eine Abfrage, die count () mit GROUP BY verwendet.
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()Geben Sie die Spalten an, mit denen aggregiert werden soll
#: AS litter_Etikettenanzahl('litter_count')Spezifiziert durch
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) # <=Fügen Sie der vorherigen Abfrage eine Zeile hinzu
q = q.with_only_columns(columns)
Der kürzere Code wäre:
q = select(events.c.name == pets.c.name) \
.where(events.c.type == 'litter') \
.group_by(events.c.name)
q = q.with_only_columns(columns)
Die Join-Bedingung wurde ohne join () in select () verschoben.
Mit SQLAlchemy können Sie Abfragen mit INNER JOIN, GROUP BY und COUNT () mit genau diesem Code schreiben.
Es ist eine schwierige Geschichte, aber als ich hier ankam, las ich verschiedene Dokumente und stellte schließlich diese Frage. SQLAlchemy ist so reich an Funktionen, dass Sie die Dokumentation einmal lesen sollten, bevor Sie sie ernsthaft verwenden. Ich hatte nicht viele japanische Informationen, also las und studierte ich Stack Overflow und andere englische Websites. Wenn Sie Python machen, ist es schwierig, wenn Sie kein Englisch sprechen können. Für Ruby gibt es dank Rails viele japanische Informationen, aber Python ist in Japan nicht beliebt, daher habe ich das Gefühl, dass es wenig Know-how gibt.
Ich denke, es wird lange dauern, bis ich es einmal verstanden habe, aber als ich es verstanden habe, wurde mir klar, dass es eine ziemlich mächtige Bibliothek ist. Ich lerne noch, daher denke ich nicht, dass der obige Schreibstil immer der beste ist, und es sollte einen besseren Schreibstil geben, der besser lesbar ist.
Ich habe viele Dokumente gesehen, die SQLAlchemy als ORM verwenden, aber ich verwende SQLAlchemy gerne als Abfrage-Generator für SELECT-Anweisungen.
Anstatt eine Bibliothek Ihres eigenen Abfrage-Generators in einem Projekt zu erstellen und dies unmöglich zu machen Ich fand es für alle viel einfacher, SQL Alchemy zu studieren und anzuwenden.
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