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

271

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

Chris Jacob
fonte
A solução é que o desenvolvedor corrija o erro que impede que o terminal seja expandido para mais do que uma única tela.
Owl
@ Owl, isso é realmente um bug? As soluções fornecidas aqui ainda não resolveram o problema?
Gathide 21/04

Respostas:

532

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
          ...
Rytmis
fonte
9
Apesar de o Windows não fazer distinção entre maiúsculas e minúsculas, isso Gdeve ser capitalizado.
Rafael Barros
3
Só para esclarecer o comentário acima, quando você digita SELECT * FROM sometable\Gvocê está enviando a string para o cliente de linha de comando mysql, não o Windows, que é por isso que o Gdiferencia maiúsculas de minúsculas
Furacão Hamilton
2
Exceto que não funciona tão bem com grandes quantidades de registros.
Błażej Michalik
1
A documentação vinculada diz: "ego (\ G) Envie o comando para o servidor mysql, exibe o resultado verticalmente. Tenha cuidado ao definir um delimitador que possa ocorrer em outras palavras. Por exemplo, se você definir o delimitador como X, não poderá use a palavra INDEX nas declarações ".
Benjamin
Eu encontrei isso. Você poderia me dizer como consertar? sh: 1: less: not found 44 rows in set (0.01 sec)
Quy Tang
347

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.

Daniel Schneller
fonte
23
isso é genialidade. excelente dica. Desde o início dos tempos, eu queria isso.
Richard H
60
pode ser redefinido usando o nopager.
22611 epeleg
3
A pesquisa em menos é feita pressionando /e, em seguida, escreva a sequência de pesquisa, que também pode ser uma expressão regular, e pressione enter. Pesquise para frente pressionando ne para trás pressionando N( Shift + n).
Krøllebølle 27/01
5
lesspode fazer coisas ainda mais legais. Usando &você pode filtrar (apenas mostrar linhas correspondentes) o resultado usando expressões regulares. Isso funciona além da /pesquisa (que ainda causará o destaque). Redefina o filtro pressionando &novamente e pressionando Return.
Daniel Schneller
3
F será encerrado menos imediatamente, se a saída já estiver na tela. X é impedir que menos tente limpar a tela na saída. Veja a página de manual menos.
Daniel Schneller
46

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.

Swiety
fonte
2
como complemento \G, você também pode usar \gcomo substituto ;, eu sei, quem faria isso, mas isso contextualiza o porquê do \Gtrabalho em primeiro lugar.
23718 santiago arizti
25

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
Ronan Boiteau
fonte
2
Este! Linda, a única maneira de tornar isso mais perfeito é ter uma maneira de ver até onde as colunas se estendem horizontalmente. Como uma barra de rolagem. No entanto, ótima solução.
Brandon Benefield
24

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    |                |
+--------------+--------------+------+-----+---------+----------------+
davidmh
fonte
8

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
+-----------+------------+------------+-------------+-------------+----------
~
~
~
hyang0
fonte
Isso funcionou melhor para mim em um contêiner leve leve. pager cut -c -200. As respostas mais aceitas aqui exigiram que eu baixasse dependências desnecessárias.
Gabriel Gates
7

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.

santiago arizti
fonte
Observe que, se você executar uma consulta "sem limite" em uma tabela grande, não perceberá o caos causado por ela, pois lesspermanecerá ancorado na primeira linha da saída.
santiago arizti
2

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"
Paul Ericson
fonte
1

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;
Pavel Stehule
fonte
0

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

Patrick Gryciuk
fonte
0

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

tee somepath\filename.txt
Sathishkumar
fonte
-1

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.

Sathishkumar
fonte