Como melhor exibir no Terminal um MySQL SELECT retornando muitos campos?

Estou usando o PuTTY para executar:

mysql> SELECT * FROM sometable;

sometablepossui muitos campos e isso resulta em muitas colunas tentando serem exibidas no terminal. Os campos passam para a próxima linha, portanto, é muito difícil alinhar os títulos das colunas com os valores dos campos.

Quais soluções existem para visualizar esses dados no terminal?

Não tenho nem quero acessar o phpMyAdmin - ou qualquer outra interface GUI. Estou procurando soluções de linha de comando como esta: Salvar resultados da consulta MySQL em texto ou arquivo CVS

Encerre a consulta com \G no lugar de ; . Por exemplo:

SELECT * FROM sometable\G

Esta consulta exibe as linhas verticalmente, assim:

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

Você também pode achar isso útil (apenas não Windows):

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

Isso conduzirá a saída através da lessferramenta de linha de comando que, com esses parâmetros, fornecerá uma saída tabular que pode ser rolada horizontal e verticalmente com as teclas do cursor.

Deixe essa visualização pressionando a qtecla que fechará a lessferramenta.

Tente ativar o modo vertical, usando \Gpara executar a consulta em vez de ;:

mysql> SELECT * FROM sometable \G

Seus resultados serão listados no modo vertical; portanto, cada valor da coluna será impresso em uma linha separada. A saída será mais estreita, mas obviamente muito mais longa.

Usando mysqlo egocomando

A partir mysqldo helpcomando:

ego (\ G) Envia o comando para o servidor mysql, exibe o resultado verticalmente.

Então, anexando a \Gao seu select, você pode obter uma saída vertical muito limpa:

mysql> SELECT * FROM sometable \G

Usando um pager

Você pode dizer ao MySQL para usar o lesspager com sua -Sopção que corta linhas largas e fornece uma saída que você pode rolar com as teclas de seta:

mysql> pager less -S

Assim, da próxima vez que você executar um comando com uma saída ampla, o MySQL permitirá navegar na saída com o lesspager:

mysql> SELECT * FROM sometable;

Se você terminou o pager e deseja voltar à saída normal stdout, use o seguinte:

mysql> nopager

Você pode usar a opção --tableou -t, que produzirá um bom conjunto de resultados

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

ou algum outro método para passar uma consulta ao mysql, como:

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

resultado:

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

O pager padrão é stdout. O stdout tem a limitação da coluna, portanto a saída seria quebrada. Você pode definir outras ferramentas como pager para formatar a saída. Existem dois métodos. Uma é limitar a coluna, a outra é processá-la no vim.

O primeiro método:

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

A saída não está completa. O conteúdo se encaixa na sua tela.

O segundo:

Defina o modo vim como nowrap no seu .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
+-----------+------------+------------+-------------+-------------+----------
~
~
~

Apenas para complementar a resposta que achei melhor, também uso de less -SFXuma maneira diferente: gosto de publicá-lo no meu .my.cnfarquivo na minha pasta pessoal, um exemplo de arquivo cnf é assim:

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

O bom de tê-lo dessa maneira é que isso lessé usado apenas quando a saída de uma consulta tem mais de uma página, aqui está a explicação de todos os sinalizadores:

• -S: Linha única, não pule a linha quando a linha for mais larga que a tela; permita rolar para a direita.
• -F: sai se uma tela , se o conteúdo não precisar ser rolado, basta enviar para stdout.
• -X: Sem init, desativa qualquer saída "less" que possa ter sido configurada para saída toda vez que é carregada.

Nota: no .my.cnfarquivo não coloque o pagercomando abaixo da [client]palavra - chave; embora possa funcionar mysqlbem, mysqldumpvai reclamar por não reconhecê-lo.

Se você estiver usando o MySQL interativamente, poderá configurar seu pager para usar da sedseguinte maneira:

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

Se você não usar sedcomo pager, a saída será a seguinte:

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

Eu escrevi pspg- https://github.com/okbob/pspg

Este pager foi projetado para dados tabulares - e o MySQL também é suportado.

MariaDB [sakila]> pager pspg -s 14 -X --force-uniborder --quit-if-one-screen
PAGER definido como 'pspg -s 14 -X --force-uniborder --quit-if-one-screen'
MariaDB [sakila]> selecione agora ();
MariaDB [sakila]> selecione * do limite nicer_but_slower_film_list 100;

Acredito que a massa tenha um número máximo de colunas que você pode especificar para a janela.

Para o Windows, eu pessoalmente uso o Windows PowerShell e defino a largura do buffer da tela razoavelmente alta. A largura da coluna permanece fixa e você pode usar uma barra de rolagem horizontal para ver os dados. Eu tive o mesmo problema que você está tendo agora.

editar: para hosts remotos nos quais você precisa fazer o SSH, você usaria algo como plink + Windows PowerShell

Você pode usar teepara gravar o resultado da sua consulta em um arquivo:

tee somepath\filename.txt

Usando o prompt de comando do Windows, você pode aumentar o tamanho do buffer da janela o quanto desejar para ver o número de colunas. Isso depende do número de colunas na tabela.