Wenn eine Datenbank viele Tabellen und Spalten enthält oder wenn Sie mit dieser Datenbank noch nicht vertraut sind, kann es eine schwierige Aufgabe sein, herauszufinden, wo Sie die Daten haben möchten.
Ich habe ein Tool namens `` `db.py``` gefunden, das in einem solchen Fall nützlich zu sein scheint, also habe ich es ausprobiert.
Im folgenden Artikel erfahren Sie, wie Sie direkt mit SQL suchen.
db.Mit py können Sie ganz einfach Folgendes tun:
* Suche nach Tabellennamen und Spaltennamen
* Abfrage ausführen
* Datenerfassung
* Speichern Sie Verbindungsinformationen für häufig verwendete Datenbanken
* Verarbeitung von Abfrageergebnissen mithilfe von Pandas-Funktionen
Es ist hilfreich, sich ein vollständiges Bild der in der Datenbank gespeicherten Daten zu machen und herauszufinden, wo sich die gewünschten Informationen befinden.
## Installation
### Installieren Sie db.py.
db.py ist in `` `Python``` geschrieben und kann mit`` pip``` installiert werden.
```bash
$ pip install db.py
Installieren Sie die Treiber, die für die Verbindung zur Datenbank erforderlich sind.
In der README-Datei in db.py finden Sie die Treiber, die für jede Datenbank verfügbar sind. Informationen zum Installieren der einzelnen Treiber finden Sie im Dokument der einzelnen Treiber.
In der README für den MySQL-Treiber ist nur "MySQLdb" geschrieben, aber Sie können auch "pymysql" verwenden. Wenn beide verfügbar sind, wird `` `MySQLdb``` verwendet.
Dieses Mal werden wir `` `SQLite``` verwenden, daher ist keine Treiberinstallation erforderlich. (Vorinstalliert.)
Verwenden Sie db.py vom Interpreter. Sie können es mit einem normalen Interpreter verwenden, aber die Verwendung von `bpython``` oder` `IPython``` ist praktisch, da Sie Funktionen wie die Vervollständigung verwenden können. Beide können mit `pip``` installiert werden.
Persönlich empfehle ich `` `bpython```, das automatisch Hilfe- und Abschlusskandidaten bereitstellt.
$ pip install bpython
$ pip install ipython
Starten Sie den Interpreter und importieren Sie die `` `DB``` Klasse.
Sie können eine Verbindung zur Datenbank herstellen, indem Sie ihr die Informationen geben, die Sie zum Herstellen einer Verbindung benötigen.
>>> from db import DB
>>> db = DB(filename="chinook.sql", dbtype="sqlite")
chinook.SQL ist db.Dies ist die Datenbank, die py für das Beispiel bereitstellt.
Sie können es auch mit `` `DemoDB``` lesen, wie es in der README geschrieben ist.
```pycon
>>> from db import DemoDB
>>> db = DemoDB()
db.Die Tabellen werden in Tabellen gespeichert.
Sie können auch überprüfen, welche Art von Spalten vorhanden sind.
```pycon
>>> db.tables
+---------------+----------------------------------------------------------------------------------+
| Table | Columns |
+---------------+----------------------------------------------------------------------------------+
| Album | AlbumId, Title, ArtistId |
| Artist | ArtistId, Name |
| Customer | CustomerId, FirstName, LastName, Company, Address, City, State, Country, PostalC |
| | ode, Phone, Fax, Email, SupportRepId |
| Employee | EmployeeId, LastName, FirstName, Title, ReportsTo, BirthDate, HireDate, Address, |
| | City, State, Country, PostalCode, Phone, Fax, Email |
| Genre | GenreId, Name |
| Invoice | InvoiceId, CustomerId, InvoiceDate, BillingAddress, BillingCity, BillingState, B |
| | illingCountry, BillingPostalCode, Total |
| InvoiceLine | InvoiceLineId, InvoiceId, TrackId, UnitPrice, Quantity |
| MediaType | MediaTypeId, Name |
| Playlist | PlaylistId, Name |
| PlaylistTrack | PlaylistId, TrackId |
| Track | TrackId, Name, AlbumId, MediaTypeId, GenreId, Composer, Milliseconds, Bytes, Uni |
| | tPrice |
+---------------+----------------------------------------------------------------------------------+
Wenn Sie sich die Informationen zu jeder Tabelle ansehen, sehen Sie Informationen wie Spaltentypen.
>>> db.tables.Customer
+------------------------------------------------------------------------+
| Customer |
+--------------+--------------+---------------------+--------------------+
| Column | Type | Foreign Keys | Reference Keys |
+--------------+--------------+---------------------+--------------------+
| CustomerId | INTEGER | | Invoice.CustomerId |
| FirstName | NVARCHAR(40) | | |
| LastName | NVARCHAR(20) | | |
| Company | NVARCHAR(80) | | |
| Address | NVARCHAR(70) | | |
| City | NVARCHAR(40) | | |
| State | NVARCHAR(40) | | |
| Country | NVARCHAR(40) | | |
| PostalCode | NVARCHAR(10) | | |
| Phone | NVARCHAR(24) | | |
| Fax | NVARCHAR(24) | | |
| Email | NVARCHAR(60) | | |
| SupportRepId | INTEGER | Employee.EmployeeId | |
+--------------+--------------+---------------------+--------------------+
all, select, unique
allMit dieser Methode können Sie alle Daten in der Tabelle abrufen.
select * from table_nameEntspricht.
lenEs kann auch in Kombination mit verwendet werden, um die Anzahl der Zeilen zu zählen.
>>> len(db.tables.Customer.all())
59
selectSie können angeben, welche Spalte verwendet werden soll.
select co1, col2, col3 from table_nameEntspricht.
>>> db.tables.Customer.select("CustomerId", "FirstName", "LastName")[:5]
CustomerId FirstName LastName
0 1 Luís Gonçalves
1 2 Leonie Köhler
2 3 François Tremblay
3 4 Bjørn Hansen
4 5 František Wichterlová
uniqueIstselectIst fast das gleiche wieselect distinctMachen.
select distinct co1, col2, col3 from table_nameEntspricht.
>>> len(db.tables.Customer.select("SupportRepId"))
59
>>> len(db.tables.Customer.unique("SupportRepId"))
3
Wenn Sie wie oben nur eine Spalte angeben, können Sie auch wie folgt schreiben.
>>> len(db.tables.Customer.SupportRepId.unique())
3
head, sample
headUm die ersten Daten mit abzurufensampleSie können Daten mit abtasten.
>>> db.tables.Customer.head(1)
CustomerId FirstName LastName \
0 1 Luís Gonçalves
Company \
0 Embraer - Empresa Brasileira de Aeronáutica S.A.
Address City State Country \
0 Av. Brigadeiro Faria Lima, 2170 São José dos Campos SP Brazil
PostalCode Phone Fax Email \
0 12227-000 +55 (12) 3923-5555 +55 (12) 3923-5566 [email protected]
SupportRepId
0 3
>>> db.tables.Customer.sample(5)
CustomerId FirstName LastName Company Address \
0 42 Wyatt Girard None 9, Place Louis Barthou
1 59 Puja Srivastava None 3,Raj Bhavan Road
2 51 Joakim Johansson None Celsiusg. 9
3 33 Ellie Sullivan None 5112 48 Street
4 52 Emma Jones None 202 Hoxton Street
City State Country PostalCode Phone Fax \
0 Bordeaux None France 33000 +33 05 56 96 96 96 None
1 Bangalore None India 560001 +91 080 22289999 None
2 Stockholm None Sweden 11230 +46 08-651 52 52 None
3 Yellowknife NT Canada X1A 1N6 +1 (867) 920-2233 None
4 London None United Kingdom N1 5LH +44 020 7707 0707 None
Email SupportRepId
0 [email protected] 3
1 [email protected] 3
2 [email protected] 5
3 [email protected] 3
4 [email protected] 3
Da die extrahierten Daten "DataFrame" von "Pandas" sind, können Sie Vorgänge ausführen, z. B. nur die erforderlichen Spalten ausschneiden oder nach einer bestimmten Spalte sortieren.
>>> db.tables.Customer.sample(5)[["CustomerId", "FirstName", "LastName", "Email"]].sort("CustomerId")
CustomerId FirstName LastName Email
1 36 Hannah Schneider [email protected]
0 46 Hugh O'Reilly [email protected]
4 51 Joakim Johansson [email protected]
2 52 Emma Jones [email protected]
3 54 Steve Murray [email protected]
find_tablesMit dieser Methode können Sie den Tabellennamen ermitteln.
Wenn Sie nach einer Tabelle suchen möchten, die die Zeichenfolgenliste enthält, gehen Sie wie folgt vor:
>>> db.find_table("*list*")
+---------------+---------------------+
| Table | Columns |
+---------------+---------------------+
| Playlist | PlaylistId, Name |
| PlaylistTrack | PlaylistId, TrackId |
+---------------+---------------------+
Sie können sowohl nach Spaltennamen als auch nach Tabellennamen suchen.
>>> db.find_column("*Name")
+-----------+-------------+---------------+
| Table | Column Name | Type |
+-----------+-------------+---------------+
| Artist | Name | NVARCHAR(120) |
| Customer | FirstName | NVARCHAR(40) |
| Customer | LastName | NVARCHAR(20) |
| Employee | FirstName | NVARCHAR(20) |
| Employee | LastName | NVARCHAR(20) |
| Genre | Name | NVARCHAR(120) |
| MediaType | Name | NVARCHAR(120) |
| Playlist | Name | NVARCHAR(120) |
| Track | Name | NVARCHAR(200) |
+-----------+-------------+---------------+
Sie können auch den Spaltentyp angeben.
>>> db.find_column("*Name", data_type="NVARCHAR(20)")
+----------+-------------+--------------+
| Table | Column Name | Type |
+----------+-------------+--------------+
| Customer | LastName | NVARCHAR(20) |
| Employee | FirstName | NVARCHAR(20) |
| Employee | LastName | NVARCHAR(20) |
+----------+-------------+--------------+
queryBei Verwendung der MethodesqlKann ausgeführt werden.
>>> db.query("SELECT CustomerId, FirstName, LastName, Email FROM Customer LIMIT 5")
CustomerId FirstName LastName Email
0 1 Luís Gonçalves [email protected]
1 2 Leonie Köhler [email protected]
2 3 François Tremblay [email protected]
3 4 Bjørn Hansen [email protected]
4 5 František Wichterlová [email protected]
Natürlich können Sie auch mitmachen.
>>> db.query("SELECT c.CustomerId, c.FirstName, e.EmployeeId, e.FirstName FROM Customer c JOIN Employee e ON c.SupportRepId = e.EmployeeId LIMIT 5")
CustomerId FirstName EmployeeId FirstName
0 1 Luís 3 Jane
1 2 Leonie 5 Steve
2 3 François 3 Jane
3 4 Bjørn 4 Margaret
4 5 František 4 Margaret
Wenn Sie die Verbindungsinformationen der häufig verwendeten Datenbank im Profil speichern, können Sie problemlos eine Verbindung über den Profilnamen herstellen.
>>> from db import list_profiles
>>> list_profiles()
{}
Sie können Ihr Profil mit der Methode `` `save_credentials``` speichern, während Sie mit der Datenbank verbunden sind. Wenn Sie den Namen weglassen, wird er "Standard" sein.
>>> db.save_profile
>>> db.save_credentials("demodb")
>>> list_profiles()
{'demodb': {u'username': None, u'dbtype': u'sqlite' ......
Sie können ganz einfach eine Verbindung mit Ihrem Profilnamen herstellen.
>>> from db import DB
>>> db = DB(profile="demodb")
remove_profileSie können das Profil mit löschen.
>>> from db import remove_profile
>>> from db import remove_profile
>>> remove_profile("demodb")
>>> db = DB(profile="demodb")
Traceback (most recent call last):
File "<input>", line 1, in <module>
File "/Users/N1212A001/virtualenv/lib/python2.7/site-packages/db/db.py", line 730, in __init__
self.load_credentials(profile)
File "/Users/N1212A001/virtualenv/lib/python2.7/site-packages/db/db.py", line 840, in load_credentials
raise Exception("Credentials not configured!")
Exception: Credentials not configured!
Selbst die Verwendung einer einfachen Funktion scheint viel Arbeit zu sparen, verglichen mit der direkten Verbindung mit der Datenbank mit dem Befehl mysql. Noch bequemer wäre es, eine Funktion zu erstellen, die häufig verwendete Abfragen ausführt und die Ergebnisse grafisch darstellt.
Recommended Posts