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

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

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

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.

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.

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

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

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

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.

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"

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;

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

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

tee somepath\filename.txt

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