[PYTHON] Rechercher une base de données avec db.py

Si vous avez beaucoup de tables et de colonnes dans une base de données, ou si vous êtes nouveau dans cette base de données, il peut être difficile de trouver où vous voulez les données.

J'ai trouvé un outil appelé `` db.py '' qui semble être utile dans un tel cas, alors je l'ai essayé.

• https://github.com/yhat/db.py

Consultez l'article suivant pour savoir comment rechercher directement avec SQL.

• Rechercher une base de données avec SQL

Ce que vous pouvez faire avec db.py

db.Avec py, vous pouvez facilement faire ce qui suit:

 * Recherche de noms de tables et de noms de colonnes
 * Exécuter l'ordre
 * Échantillonnage des données
 * Enregistrer les informations de connexion pour les bases de données fréquemment utilisées
 * Traitement des résultats des requêtes à l'aide des fonctionnalités de pandas

 Il est utile d'avoir une image complète des données stockées dans la base de données et de savoir où se trouvent les informations souhaitées.

## Installation

### Installez db.py

 db.py est écrit en `` `` Python``` et peut être installé avec` `` pip```.

```bash
$ pip install db.py

Installation du pilote

Installez les pilotes nécessaires pour vous connecter à la base de données.

Voir le README dans db.py pour les pilotes disponibles pour chaque base de données. Pour savoir comment installer chaque pilote, reportez-vous au document de chaque pilote.

Seul MySQLdb``` est écrit dans le README pour le pilote MySQL, mais vous pouvez également utiliser pymysql```. Si les deux sont disponibles, MySQLdb '' sera utilisé.

Cette fois, nous utiliserons `` SQLite '', donc aucune installation de pilote n'est requise. (Pre installé.)

Installation de bpython et ipython

Utilisez db.py de l'interpréteur. Vous pouvez l'utiliser avec un interpréteur normal, mais utiliser bpythonouIPython est pratique car vous pouvez utiliser des fonctions telles que la complétion. Les deux peuvent être installés avec `` `` pip.

Personnellement, je recommande `` bpython '', qui fournit automatiquement de l'aide et des candidats à la complétion.

$ pip install bpython
$ pip install ipython

Connectez-vous à la base de données

Démarrez l'interpréteur et importez la classe `` DB ''.

Vous pouvez vous connecter à la base de données en lui donnant les informations dont vous avez besoin pour vous connecter.

>>> from db import DB
>>> db = DB(filename="chinook.sql", dbtype="sqlite")

chinook.sql est db.Il s'agit de la base de données fournie par py pour l'exemple.

 Vous pouvez également le lire en utilisant `` DemoDB '' tel qu'il est écrit dans le README.

```pycon
>>> from db import DemoDB
>>> db = DemoDB()

Afficher une liste de tableaux

db.Les tables sont stockées dans des tables.

 Vous pouvez également vérifier le type de colonnes qu'il existe.

```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                                                                           |
+---------------+----------------------------------------------------------------------------------+

Si vous regardez les informations sur chaque table, vous pouvez voir des informations telles que les types de colonnes.

>>> 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 |                    |
+--------------+--------------+---------------------+--------------------+

Récupérer les données d'une table

all, select, unique

allVous pouvez utiliser la méthode pour récupérer toutes les données de la table. select * from table_nameCorrespond à.

lenIl peut également être utilisé en combinaison avec pour compter le nombre de lignes.

>>> len(db.tables.Customer.all())
59

selectVous pouvez spécifier la colonne à utiliser. select co1, col2, col3 from table_nameCorrespond à.

>>> 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á

uniqueEstselectEst presque le même queselect distinctFaire. select distinct co1, col2, col3 from table_nameCorrespond à.

>>> len(db.tables.Customer.select("SupportRepId"))
59
>>> len(db.tables.Customer.unique("SupportRepId"))
3

Si vous spécifiez une seule colonne comme ci-dessus, vous pouvez également écrire comme suit.

>>> len(db.tables.Customer.SupportRepId.unique())
3

head, sample

headPour récupérer les premières données avecsampleVous pouvez échantillonner des données avec.

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

Fonctionnement utilisant la fonction de pandas

Puisque les données extraites sont DataFrame``` de` pandas```, vous pouvez effectuer des opérations telles que couper uniquement les colonnes nécessaires ou trier par une colonne spécifique.

>>> 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]

Rechercher une table / colonne

find_tablesVous pouvez utiliser la méthode pour trouver le nom de la table. Si vous souhaitez rechercher une table contenant la liste de chaînes, procédez comme suit:

>>> db.find_table("*list*")
+---------------+---------------------+
| Table         | Columns             |
+---------------+---------------------+
| Playlist      | PlaylistId, Name    |
| PlaylistTrack | PlaylistId, TrackId |
+---------------+---------------------+

Vous pouvez rechercher des noms de colonnes ainsi que des noms de tables.

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

Vous pouvez également spécifier le type de colonne.

>>> db.find_column("*Name", data_type="NVARCHAR(20)")
+----------+-------------+--------------+
| Table    | Column Name | Type         |
+----------+-------------+--------------+
| Customer |   LastName  | NVARCHAR(20) |
| Employee |  FirstName  | NVARCHAR(20) |
| Employee |   LastName  | NVARCHAR(20) |
+----------+-------------+--------------+

Exécuter l'ordre

queryLors de l'utilisation de la méthodesqlPeut être exécuté.

>>> 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]

Bien sûr, vous pouvez également REJOINDRE.

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

Utilisation du profil

Si vous enregistrez les informations de connexion de la base de données fréquemment utilisée dans le profil, vous pouvez facilement vous connecter en utilisant le nom du profil.

Afficher le profil existant

>>> from db import list_profiles
>>> list_profiles()
{}

Enregistrer le profil

Vous pouvez enregistrer votre profil en utilisant la méthode save_credentials '' lorsque vous êtes connecté à la base de données. Si vous omettez le nom, ce sera par défaut ''.

>>> db.save_profile
>>> db.save_credentials("demodb")
>>> list_profiles()
{'demodb': {u'username': None, u'dbtype': u'sqlite' ......

Connexion à une base de données à l'aide d'un profil

Vous pouvez facilement vous connecter en utilisant votre nom de profil.

>>> from db import DB
>>> db = DB(profile="demodb")

Supprimer le profil

remove_profileVous pouvez supprimer le profil avec.

>>> 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!

Résumé

Même l'utilisation d'une fonction simple semble économiser beaucoup de travail par rapport à la connexion directe à la base de données avec la commande mysql. Je pense qu'il serait encore plus pratique de créer une fonction qui exécute les requêtes fréquemment utilisées et trace les résultats.