web-dev-qa-db-fra.com

Comment afficher au mieux dans un terminal un MySQL SELECT renvoyant trop de champs?

J'utilise PuTTY pour exécuter:

mysql> SELECT * FROM sometable;

sometable comporte de nombreux champs, ce qui a pour conséquence que de nombreuses colonnes tentent de s'afficher dans le terminal. Les champs se superposent à la ligne suivante, il est donc très difficile d'aligner les titres de colonne avec les valeurs de champ.

Quelles sont les solutions pour afficher de telles données dans un terminal?

Je n'ai ni ne veux accéder à phpMyAdmin - ni à aucune autre interface graphique. Je recherche des solutions en ligne de commande telles que celle-ci: enregistrer les résultats de la requête MySQL dans un fichier texte ou CVS

mysqlcommand-lineselectputty
242
Chris Jacob

Terminez la requête avec \G à la place de ;. Par exemple:

SELECT * FROM sometable\G

Cette requête affiche les lignes verticalement, comme ceci:

*************************** 1. row ***************************
                 Host: localhost
                   Db: mydatabase1
                 User: myuser1
          Select_priv: Y
          Insert_priv: Y
          Update_priv: Y
          ...
*************************** 2. row ***************************
                 Host: localhost
                   Db: mydatabase2
                 User: myuser2
          Select_priv: Y
          Insert_priv: Y
          Update_priv: Y
          ...
452
Rytmis

Vous pouvez également trouver cela utile (non-Windows uniquement):

mysql> pager less -SFX
mysql> SELECT * FROM sometable;

Cela acheminera la sortie via l'outil de ligne de commande less qui, avec ces paramètres, vous donnera une sortie tabulaire que vous pourrez faire défiler horizontalement et verticalement à l'aide des touches de direction.

Quittez cette vue en appuyant sur la touche q, ce qui permet de quitter l'outil less.

321
Daniel Schneller

Essayez d'activer le mode vertical en utilisant \G pour exécuter la requête au lieu de ;:

mysql> SELECT * FROM sometable \G

Vos résultats seront listés en mode vertical, ainsi chaque valeur de colonne sera imprimée sur une ligne séparée. La sortie sera plus étroite mais évidemment beaucoup plus longue.

42
Swiety

Vous pouvez utiliser l'option --table ou -t, qui générera un ensemble de résultats d'aspect agréable

echo 'desc table_name' | mysql -uroot database -t

ou une autre méthode pour passer une requête à mysql, comme:

mysql -uroot table_name --table < /tmp/somequery.sql

sortie:

+--------------+--------------+------+-----+---------+----------------+
| Field        | Type         | Null | Key | Default | Extra          |
+--------------+--------------+------+-----+---------+----------------+
| id           | int(11)      | NO   | PRI | NULL    | auto_increment |
| username     | varchar(30)  | NO   | UNI | NULL    |                |
| first_name   | varchar(30)  | NO   |     | NULL    |                |
| last_name    | varchar(30)  | NO   |     | NULL    |                |
| email        | varchar(75)  | NO   |     | NULL    |                |
| password     | varchar(128) | NO   |     | NULL    |                |
| is_staff     | tinyint(1)   | NO   |     | NULL    |                |
| is_active    | tinyint(1)   | NO   |     | NULL    |                |
| is_superuser | tinyint(1)   | NO   |     | NULL    |                |
| last_login   | datetime     | NO   |     | NULL    |                |
| date_joined  | datetime     | NO   |     | NULL    |                |
+--------------+--------------+------+-----+---------+----------------+
22
davidmh

Utilisation de la commande mysql 'ego

De la commande mysql 'help:

ego (\ G) Envoie la commande au serveur mysql, affiche le résultat verticalement.

Donc, en ajoutant un \G à votre select, vous pouvez obtenir une sortie verticale très nette:

mysql> SELECT * FROM sometable \G;

Utiliser un pager

Vous pouvez demander à MySQL d'utiliser le paginateur less avec son option -S qui coupe les lignes larges et vous donne une sortie que vous pouvez faire défiler à l'aide des touches fléchées:

mysql> pager less -S

Ainsi, la prochaine fois que vous exécuterez une commande avec une sortie large, MySQL vous permettra de parcourir la sortie avec le pager less:

mysql> SELECT * FROM sometable;

Si vous en avez terminé avec le pageur et souhaitez revenir à la sortie normale sur stdout, utilisez ceci:

mysql> nopager
18
Ronan Boiteau

Le pager par défaut est stdout. La sortie standard a la limitation de colonne, ainsi la sortie serait encapsulée. Vous pouvez définir d'autres outils comme pageur pour formater la sortie. Il y a deux méthodes. L'une consiste à limiter la colonne, l'autre à la traiter dans vim.

La première méthode:

➜  ~  echo $COLUMNS
179

mysql> nopager
PAGER set to stdout
mysql> pager cut -c -179
PAGER set to 'cut -c -179'
mysql> select * from db;
+-----------+------------+------------+-------------+-------------+-------------+-------------+-------------+-----------+------------+-----------------+------------+------------+-
| Host      | Db         | User       | Select_priv | Insert_priv | Update_priv | Delete_priv | Create_priv | Drop_priv | Grant_priv | References_priv | Index_priv | Alter_priv |
+-----------+------------+------------+-------------+-------------+-------------+-------------+-------------+-----------+------------+-----------------+------------+------------+-
| %         | test       |            | Y           | Y           | Y           | Y           | Y           | Y         | N          | Y               | Y          | Y          |
| %         | test\_%    |            | Y           | Y           | Y           | Y           | Y           | Y         | N          | Y               | Y          | Y          |
| localhost | phpmyadmin | phpmyadmin | Y           | Y           | Y           | Y           | Y           | Y         | N          | Y               | Y          | Y          |
| localhost | it         | it         | Y           | Y           | Y           | Y           | Y           | Y         | N          | Y               | Y          | Y          |
+-----------+------------+------------+-------------+-------------+-------------+-------------+-------------+-----------+------------+-----------------+------------+------------+-
4 rows in set (0.00 sec)

mysql>

La sortie n'est pas complète. Le contenu s'adapte à votre écran.

Le deuxième:

Définissez le mode vim pour qu'il soit maintenant dans votre fichier .vimrc

➜  ~  tail ~/.vimrc

" no-wrap for myslq cli
set nowrap

mysql> pager vim -
PAGER set to 'vim -'
mysql> select * from db;
    Vim: Reading from stdin...
+-----------+------------+------------+-------------+-------------+----------
| Host      | Db         | User       | Select_priv | Insert_priv | Update_pr
+-----------+------------+------------+-------------+-------------+----------
| %         | test       |            | Y           | Y           | Y
| %         | test\_%    |            | Y           | Y           | Y
| localhost | phpmyadmin | phpmyadmin | Y           | Y           | Y
| localhost | it         | it         | Y           | Y           | Y
+-----------+------------+------------+-------------+-------------+----------
~
~
~
7
hyang0

Juste pour compléter la réponse qui me semblait préférable, j'utilise aussi less -SFX, mais d'une manière différente: j'aime l'adapter à mon fichier .my.cnf dans mon dossier de départ, un exemple de fichier cnf ressemblant à ceci:

[client]
user=root
password=MyPwD
[mysql]
pager='less -SFX'

L’avantage de l’avoir de cette façon, c’est que less n’est utilisé que lorsque le résultat d’une requête a en réalité plus d’une page, voici l’explication de tous les drapeaux:

  • -S: Une seule ligne, ne sautez pas de ligne lorsque celle-ci est plus large que l’écran, mais permettent plutôt de faire défiler vers la droite.
  • -F: Quitter si un écran, si le contenu n'a pas besoin de défilement, envoyez-le simplement à stdout.
  • -X: No init, désactive toute sortie "less" peut-être configurée pour sortir à chaque chargement.

Remarque: dans le fichier .my.cnf, ne placez pas la commande pager sous le mot clé [client]; bien que cela puisse fonctionner avec mysql eh bien, mysqldump se plaindra de ne pas le reconnaître.

6
santiago arizti

Si vous utilisez MySQL de manière interactive, vous pouvez configurer votre pageur pour qu'il utilise sed comme ceci:

$ mysql -u <user> p<password>
mysql> pager sed 's/,/\n/g' 
PAGER set to 'sed 's/,/\n/g''
mysql> SELECT blah FROM blah WHERE blah = blah 
.
.
.
"blah":"blah"
"blah":"blah"
"blah":"blah"

Si vous n'utilisez pas sed comme pageur, le résultat est le suivant:

"blah":"blah","blah":"blah","blah":"blah"
2
Paul Ericson

J'ai écrit pspg - https://github.com/okbob/pspg

Ce pager est conçu pour les données tabulaires - et MySQL est également supporté.

 MariaDB [sakila]> pager pspg -s 14 -X --force-uniborder --quit-si-un-écran 
 PAGER réglé sur 'pspg -s 14 -X --force- uniborder --quit-si-un-écran '
 MariaDB [sakila]> sélectionnez maintenant (); 
 MariaDB [sakila]> sélectionnez * parmi nicer_but_slower_film_list limite 100;
1
Pavel Stehule

Vous pouvez utiliser tee pour écrire le résultat de votre requête dans un fichier:

tee somepath\filename.txt
0
Sathishkumar

En utilisant l'invite de commande Windows, vous pouvez augmenter la taille de la mémoire tampon de la fenêtre autant que vous le souhaitez pour afficher le nombre de colonnes. Cela dépend du nombre de colonnes dans la table.

0
Sathishkumar

Je pense que PuTTY a un nombre maximum de colonnes que vous pouvez spécifier pour la fenêtre.

Pour Windows, j'utilise personnellement Windows PowerShell et j'affine la largeur du tampon d'écran à une valeur raisonnablement élevée. La largeur de la colonne reste fixe et vous pouvez utiliser une barre de défilement horizontale pour voir les données. J'ai eu le même problème que vous avez maintenant.

edit: pour les hôtes distants que vous devez entrer en SSH, vous utiliseriez quelque chose comme plink + Windows PowerShell

0
Patrick Gryciuk