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


271

J'utilise PuTTY pour exécuter:

mysql> SELECT * FROM sometable;

sometablea de nombreux champs et cela se traduit par de nombreuses colonnes essayant d'être affichées dans le terminal. Les champs passent à la ligne suivante, il est donc très difficile d'aligner les titres des colonnes avec les valeurs des champs.

Quelles sont les solutions pour visualiser ces données dans le terminal?

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


La solution consiste pour le développeur à corriger le bogue qui empêche le terminal d'être étendu à un écran plus large qu'un seul écran.
Owl

@Owl, est-ce vraiment un bug? Les solutions fournies ici n'ont-elles pas encore résolu le problème?
Gathide

Réponses:


532

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

9
Bien que Windows ne soit pas sensible à la casse, cela Gdoit être capitalisé.
Rafael Barros

3
Juste pour clarifier le commentaire ci-dessus, lorsque vous tapez, SELECT * FROM sometable\Gvous envoyez la chaîne au client de ligne de commande mysql, pas à Windows, c'est pourquoi le Gest sensible à la casse
Hurricane Hamilton

2
Sauf que cela ne fonctionne pas très bien avec de grandes quantités d'enregistrements.
Błażej Michalik

1
La documentation liée indique: "ego (\ G) Envoyer la commande au serveur mysql, afficher le résultat verticalement. Faites attention à définir un délimiteur qui pourrait se produire entre d'autres mots. Par exemple, si vous définissez le délimiteur comme X, vous ne pourrez pas utilisez le mot INDEX dans les instructions. "
Benjamin

J'ai rencontré ça. Pourriez-vous s'il vous plaît me dire comment y remédier? sh: 1: less: not found 44 rows in set (0.01 sec)
Quy Tang

347

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

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

Cela dirigera la sortie à travers l' lessoutil de ligne de commande qui - avec ces paramètres - vous donnera une sortie tabulaire qui peut être défilée horizontalement et verticalement avec les touches de curseur.

Quittez cette vue en appuyant sur la qtouche, ce qui fermera l' lessoutil.


23
c'est génial. excellent conseil. Depuis la nuit des temps, je le veux.
Richard H

60
peut être réinitialisé à l'aide de nopager.
epeleg

3
La recherche dans moins se fait en appuyant sur /puis en écrivant la chaîne de recherche, qui peut également être des expressions rationnelles, puis en appuyant sur Entrée. Recherchez en avant en appuyant sur net en arrière en appuyant sur N( Shift + n).
Krøllebølle

5
lesspeut faire des choses encore plus cool. En utilisant, &vous pouvez filtrer (afficher uniquement les lignes correspondantes) le résultat en utilisant des expressions régulières. Cela fonctionne en plus de la /recherche (qui provoquera toujours la mise en évidence). Réinitialisez le filtre en appuyant de &nouveau, puis en appuyant simplement sur Retour.
Daniel Schneller

3
F quittera moins immédiatement si la sortie correspond déjà à l'écran. X est d'empêcher moins d'essayer d'effacer l'écran à la sortie. Voir la page de manuel less.
Daniel Schneller

46

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

mysql> SELECT * FROM sometable \G

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


2
en complément de \G, vous pouvez également utiliser \gpour remplacer ;, je sais, qui ferait cela, mais cela donne un contexte pour expliquer pourquoi \Gtravailler en premier lieu.
santiago arizti

25

Utilisation de mysqlla egocommande

De mysqlla helpcommande de:

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

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

mysql> SELECT * FROM sometable \G

Utiliser un téléavertisseur

Vous pouvez dire à MySQL d'utiliser le lesspager avec son -Soption qui coupe les lignes larges et vous donne une sortie que vous pouvez faire défiler avec les 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 lesspager:

mysql> SELECT * FROM sometable;

Si vous avez terminé avec le pager et que vous souhaitez revenir à la sortie régulière stdout, utilisez ceci:

mysql> nopager

2
Ce! Belle, la seule façon de rendre cela plus parfait est d'avoir un moyen de voir jusqu'où les colonnes s'étendent horizontalement. Comme une barre de défilement. Néanmoins, une excellente solution.
Brandon Benefield

24

Vous pouvez utiliser l' option --tableou -t, qui produira un bel ensemble de résultats

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

production:

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

8

Le pager par défaut est stdout. La sortie standard a la limitation de colonne, de sorte que la sortie serait encapsulée. Vous pouvez définir d'autres outils comme pager pour formater la sortie. Il existe 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 terminée. Le contenu s'adapte à votre écran.

Le deuxième:

Réglez le mode vim pour qu'il s'enclenche maintenant dans votre .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
+-----------+------------+------------+-------------+-------------+----------
~
~
~

Cela a fonctionné le mieux pour moi dans un conteneur docker léger. pager cut -c -200. Les réponses les plus acceptées ici m'ont obligé à télécharger des dépendances inutiles.
Gabriel Gates

7

Juste pour compléter la réponse que je pensais le mieux, j'utilise également, less -SFXmais d'une manière différente: j'aime l' .my.cnfajouter à mon fichier dans mon dossier d'accueil, un exemple de fichier cnf ressemble à ceci:

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

L'avantage de l'avoir de cette façon, c'est qu'il lessn'est utilisé que lorsque la sortie d'une requête fait en fait plus d'une page, voici l'explication de tous les indicateurs:

  • -S: une seule ligne, ne sautez pas de ligne lorsque la ligne est plus large que l'écran, laissez plutôt défiler vers la droite.
  • -F: Quittez si un écran , si le contenu n'a pas besoin de défiler, envoyez simplement à stdout.
  • -X: pas d'initialisation, désactive toute sortie "moins" qui aurait pu être configurée pour sortir à chaque chargement.

Remarque: dans le .my.cnffichier, ne placez pas la pagercommande sous le [client]mot - clé; même si cela pourrait mysqlbien fonctionner, mysqldumpse plaindra de ne pas le reconnaître.


Notez que si vous exécutez une requête "sans limite" sur une grande table, vous ne remarquerez pas le chaos provoqué par celle-ci, car lesselle restera ancrée à la première ligne de la sortie.
santiago arizti

2

Si vous utilisez MySQL de manière interactive, vous pouvez configurer votre pager pour qu'il utilise sedcomme 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 ne l'utilisez pas sedcomme pager, la sortie est la suivante:

"blah":"blah","blah":"blah","blah":"blah"

1

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

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

MariaDB [sakila]> pager pspg -s 14 -X --force-uniborder --quit-if-one-screen
PAGER réglé sur 'pspg -s 14 -X --force-uniborder --quit-if-one-screen'
MariaDB [sakila]> sélectionner maintenant ();
MariaDB [sakila]> sélectionnez * à partir de nicer_but_slower_film_list limit 100;

0

Je crois que le mastic a un nombre maximum de colonnes que vous pouvez spécifier pour la fenêtre.

Pour Windows, j'utilise personnellement Windows PowerShell et définit une largeur de tampon d'écran raisonnablement élevée. La largeur de 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 rencontrez maintenant.

modifier: Pour les hôtes distants que vous devez connecter à SSH, vous utiliseriez quelque chose comme plink + Windows PowerShell


0

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

tee somepath\filename.txt

-1

À l'aide de l'invite de commandes Windows, vous pouvez augmenter la taille de la mémoire tampon de la fenêtre autant que vous le souhaitez pour voir le nombre de colonnes. Cela dépend du nombre de colonnes dans le tableau.

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.