Como listar resultados das tabelas com linhas numeradas no MySQL

Veja como numerar cada linha do resultado de uma query no MySQL. A solução pode ser implementada com uma saída pós processada ou com o uso de uma variável SQL.
mysql numbered lines tables
Neste texto, vou mostrar 2 maneiras bem objetivas e práticas para obter os resultados de uma query (ou consulta) MySQL em linhas numeradas, dentro de uma tabela.

Como obter uma relação numerada de itens de uma tabela via linha de comando

Na linha de comando do Linux ou Unix, você pode combinar a execução de código MySQL com o comando cat -n, conforme é possível observar no exemplo abaixo:

mysql -u root -p -N -e "SELECT nome, credito FROM minhaTabela" tutorial | cat -n
Enter password: 
     1	Geoffrey Rojas	9.33
     2	Brenda N. Reynolds	9.03
     3	Unity Peterson	9.19
     4	Gay Warren	9.11
     5	Hedda E. Kaufman	9.71
     6	Audrey X. Silva	9.21
     7	Myra J. Wright	9.49
     8	Wilma Bird	9.45
     9	Thaddeus P. Shaw	9.06

Com este método, não é preciso entrar no MySQL para conseguir realizar a tarefa.
Vamos dissecar o comando?

  1. mysql -u root -p— início clássico para entrar no cliente MySQL, como root. Como a senha não é fornecida na linha de comando, ela será pedida a seguir.
  2. -N— faz com que a saída do comando não exiba os nomes das colunas.
  3. -e— executa o comando, que segue entre aspas e sai do cliente MySQL. Opcionalmente, você pode usar a variante --execute.
  4. "SELECT nome, credito FROM minhaTabela"query ou consulta a ser executada.
  5. tutorial— banco de dados a ser inquirido.
  6. | cat -n— direciona a saída ao comando cat. A opção -n especifica que cada linha deverá ser contada e numerada.

Neste caso, portanto, quem numera as linhas não é o MySQL, mas o utilitário cat.
Em listas muito grandes, este método permite usar o comando grep, para filtrar os resultados.
Se você tem interesse em saber mais sobre como executar queries MySQL da linha de comando do Linux/Unix, leia este artigo.

Use uma variável SQL para obter uma lista numerada

Uma alternativa inteligente, para solucionar o problema é usar uma variável auto incrementável para listar as linhas numeradas.
Esta solução, ao contrário da anterior, pede que você execute os comandos de dentro do cliente MySQL.
Veja o exemplo:

SET @n = 0;
Query OK, 0 rows affected (0.00 sec)

SELECT @n := @n+1 AS ordem, nome, credito, debito FROM minhaTabela;
+-------+-----------------------+---------+--------+
| ordem | nome                  | credito | debito |
+-------+-----------------------+---------+--------+
|     1 | Lani Z. Lawrence      | 4.70    | 2.01   |
|     2 | Geoffrey Rojas        | 9.33    | 6.09   |
|     3 | Holly Mcknight        | 3.79    | 9.84   |
|     4 | Emerson F. Tate       | 6.09    | 8.57   |
|     5 | Alyssa A. Goodman     | 3.29    | 4.73   |
|     6 | Kibo H. Cruz          | 8.52    | 6.41   |
|     7 | May Hoffman           | 5.51    | 2.40   |
|     8 | Heidi F. Lawson       | 8.37    | 1.42   |
|     9 | Isaac U. Herring      | 6.85    | 1.93   |
|    10 | Amanda Roberson       | 5.97    | 9.47   |
|    11 | Oren M. Tanner        | 4.05    | 9.96   |
|    12 | Wyatt Becker          | 2.81    | 2.81   |
+-------+-----------------------+---------+--------+
12 rows in set (0.00 sec)

Dissecando o comando:

  1. SET @n = 0; — define a variável @n com o valor 0.
  2. SELECT @n := @n+1 AS ordem, nome, credito, debito FROM minhaTabela; — a segunda linha de comando é a responsável pela confecção e exibição da lista.

Se você gostaria de entender melhor o uso de variáveis no MySQL, leia este tutorial.

Como enviar queries pro MySQL da linha de comando

O MySQL aceita queries direto da linha de comando, o que poupa tempo para realizar tarefas rápidas e evita ter que usar o modo interativo provido pelo cliente.
O conceito é simples e você provavelmente já o viu ser aplicado a inúmeros outros programas.
Oracle and MySQL logos
Uma query pode ser fornecida ao MySQL, diretamente da linha de comando, com a adição da opção -e (ou –execute) ao cliente.
O exemplo abaixo mostra como ver a quantidade de registros em na tabela clientes, dentro do banco de dados admin:

mysql -e "SELECT COUNT(*) FROM clientes" admin
+----------+
| COUNT(*) |
+----------+
|
12 |
+----------+

Se quiser usar mais de uma query, faça como sempre — separe as queries com ; (ponto e vírgula):

mysql -e "SELECT COUNT(*) FROM clientes;SELECT NOW( )" admin
+----------+
| COUNT(*) |
+----------+
|
12 |
+----------+
+---------------------+| NOW( )
|
+---------------------+
| 2001-07-04 10:42:22 |
+---------------------+

Como se prevenir de fork bombs no Linux, usando nproc e ulimit

fork bombs são códigos maliciosos, executados no sistema, que causam a negação do serviço ou denial of service.
Sua efeito é devastador, por consumir rapidamente os recursos de armazenamento na memória e/ou de processamento de informações, causando uma crescente deterioração do sistema.
fork bomb diagram
O resultado de uma fork bomb é, quase sempre, um desktop ou servidor totalmente inoperante — neste caso, tudo o que resta a fazer é reiniciar a máquina, sob o risco de perder dados importantes e corromper arquivos fundamentais do sistema.
Veja o vídeo, ao final do artigo, demonstrativo da execução de uma fork bomb no meu sistema.
As fork bombs não são defeitos ou falhas na arquitetura do seu sistema operacional. Na verdade, cabe ao administrador configurar o sistema para que os processos não consumam todos os seus recursos.
Neste artigo, vamos demonstrar como é possível, com alguns procedimentos simples, limitar os recursos disponíveis aos usuários, que podem prevenir o uso malicioso do sistema.

Estabeleça limites para seus usuários com nproc

Uma fork bomb funciona criando uma quantidade exponencial e infindável de processos (muito rapidamente), com o objetivo de saturar o espaço disponível para outros processos — o que inclui os do próprio sistema operacional.

Uma fork bomb mata o seu sistema por inanição de recursos

Configure o arquivo /etc/security/limits.conf para que este imponha limites aos usuários e processos.
Abra o arquivo, com privilégios administrativos e altere a quantidade de processos que usuários e grupos de usuários podem abrir simultaneamente.
Por exemplo, para estabelecer a quantidade máxima de processos do usuário ‘salsicha’ para 300, adicione o seguinte código:

salsicha hard nproc 300

Para limitar a quantidade de processos dos usuários pertencentes ao grupo ‘scoobydoo’ em 50, use o seguinte exemplo:

@scoobydoo hard nproc 50

Com esta configuração, o usuário ‘salsicha’ ou qualquer outro pertencente ao grupo ‘scoobydoo’ ficará impedido de derrubar o sistema com uma fork bomb.
Se tentarem, o sistema ficará indisponível apenas para eles — os usuários e grupos em questão.
Outros usuários no sistema não serão afetados.
É necessário reiniciar o sistema, depois de alterar o arquivo de configuração.

Como limitar a quantidade de processos em uma sessão com ulimit

Um método mais imediato de limitar o número de processos por sessão consiste no uso do comando ulimit.

ulimit -u
841

Conforme o resultado acima, o meu usuário está limitado a abrir até 841 processos simultaneamente.
Tome cuidado ao reduzir o número de processos. Um valor muito baixo pode simplesmente inviabilizar o uso.
Para reduzir o número máximo de processos abertos simultâneos para esta sessão para 30, faça assim:

ulimit -u 30

Se você tentar rodar uma fork bomb agora, ela irá ser executada, mas irá emitir um monte de mensagens:
-bash: fork: retry: recurso temporariamente indisponível
-bash: fork: retry: Não há processos filhos
Isto significa que seu sistema não permitiu que a bomba abrisse mais processos além do limite.
No final, a bomba é finalizada pelo sistema. Veja a imagem:

$ :(){ :|:& };:
Fork Bomb
:(){ :|:& };:

Leve em conta que cada sistema é único.
Se você usa um desktop KDE ou Gnome, precisa imaginar que eles tendem a abrir uma grande quantidade de processos para poder funcionar.

Demonstração real de uma fork bomb em execução

No vídeo abaixo, fica demonstrada execução de uma fork bomb sob controle do ulimit — pouco tempo depois de começar a agir, ela é neutralizada pelo sistema.

Eu usei uma máquina virtual, rodando o Debian 8.1 Jessie, para realizar a demonstração.
Se quiser saber como por no ar a sua própria máquina virtual, leia o artigo Como pôr no ar uma máquina virtual Debian, em 5 minutos.

Achou interessante? Compartilhe! 🙂

O que é uma fork bomb?

Neste post, vou mostrar como funcionam as fork bombs, como fazer uma e como se prevenir deste tipo de código malicioso.
Além das diversas definições, sempre há uma história por ser contada e é por onde vou começar.
Ao final do texto, há alguns links para outros sites onde o assunto também é abordado, caso você queira se aprofundar mais no assunto.
Pernalonga e Elmer Fudd
Se o seu interesse é prevenção, leia Como prevenir a execução de uma fork bomb no seu sistema.

Qual a definição de fork bomb?

Uma definição simples para fork bomb é a de que se trata de um código que tenha a função e a capacidade de se replicar indefinidamente.
Vírus e vermes não valem para esta definição.
À medida em que o código vai auto replicando, consome cada vez mais recursos de memória, de processamento etc.
Como os recursos do sistema não são inesgotáveis, o resultado é que ele entra em colapso.
Há relatos de que códigos deste tipo foram executados por estudantes, na Universidade de Washington, em um Burroughs 5500, em 1969 — o programa fazia 2 cópias de si mesmo, a cada vez em que era executado até que o sistema fosse derrubado.
A esta rápida reprodução do código deve-se o apelido de “trabalho de coelho” (rabbit job) ou wabbit, em alusão ao personagem da Looney Tunes, Elmer Fudd, que trocava o R pelo L (veja link ao final do texto) — a piada só tem graça em inglês.

Como criar uma fork bomb no Ubuntu

Você não precisa ser super usuário para criar e rodar uma fork bomb na maioria das vezes. Normalmente, cabe ao administrador do sistema regular como cada usuário irá usar os recursos.
error iconO código abaixo é um dos mais conhecidos e torna o seu sistema cada vez mais lento, a ponto de parar de responder completamente.
Este código e todos os outros, neste artigo, podem quebrar o seu sistema. Seja responsável!

:(){ :|: & };:

O seu funcionamento é o seguinte:

  • :() — cria/define uma função chamada :
  • {:|: &} — roda a função : e direciona sua saída para a função : e a executa nos bastidores
  • ; — este caractere funciona como separador, na linha de comandos. Equivale a && e permite iniciar uma outra instrução
  • : — executa a função definida no início

É possível desarmar esta bomba com o comando kill, no Linux — mas você provavelmente vai precisar ser muito rápido para fazer isto antes que seu sistema morra por inanição de recursos.
Uma outra forma, mais compreensível, de obter o mesmo resultado nefasto é assim:

bomba()
 {
bomba | bomba &
 }; bomba

No código, acima, fica mais claro ver a função executar-se a si mesma.
Se você gostaria de ver um exemplo não malicioso de execução de uma fork bomb, o código abaixo é seguro para você experimentar:

fork_bomb(){ echo "FORK BOMB"; };
fork_bomb

No terminal, ele pode ser interrompido com Ctrl+C.

Como criar uma fork bomb no Windows

Você pode criar um arquivo .bat, com o seguinte conteúdo:

:bomba
start %0
goto bomba

Ou rodar este código:

%0|%0

As fork bombs funcionam como esquemas de negação de serviço (denial of service) — elas devoram os recursos do sistema.

Como criar uma fork bomb em Perl, Python e em C

Exemplo em Perl:

perl -e "fork while fork" &

Em Python:

import os
  while(1):
      os.fork()

E, por último, uma fork bomb em linguagem C:

#include
int main()
 {
   while(1)
      fork();
 }

Referências

Como se prevenir de uma fork bomb.
Comandos fatais para Linux.
Cyberciti — Understanding fork bomb.
Linuxconfig — How to crash your system with a fork bomb.
Hortelino Troca-Letras (Elmer Fudd) — http://pt.wikipedia.org/wiki/Elmer_Fudd.
The hackers jargon — http://catb.org/~esr/jargon/html/W/wabbit.html.

Como criar links e atalhos no Linux.

A criação de links e atalhos ajuda a chegar mais rápido a arquivos e diretórios (ou pastas) em qualquer ambiente.
Neste texto vou mostrar como realizar a tarefa no ambiente gráfico e no terminal — vale a pena conhecer as duas maneiras.
captura de tela da lista de arquivos no Thunar

Crie atalhos no painel lateral do gerenciador de arquivos

O painel lateral (usualmente, à esquerda) do gerenciador de arquivos já abriga alguns atalhos úteis para a maioria dos usuários.
Você pode adicionar os seus, se quiser.
Para isto, arraste um arquivo ou uma pasta, do painel central para dentro da lista de atalhos no painel lateral.
Veja a figura:

Captura de tela do gerenciador de arquivos Thunar, no Xubuntu
Clique, para ver detalhes.

Saiba como criar atalhos na linha de comando

O comando para criar links, no terminal do Linux, é o ln.
O seu funcionamento é simples e você deve informar, antes de executar, o tipo de atalho, o diretório a ser linkado e o nome do link.
Veja um exemplo de criação de um link simbólico:

ln -s /var/www/html/ site

Os detalhes do comando acima:

  • -s — o tipo de link a ser criado: simbólico.
  • /var/www/html/ — o diretório a ser linkado.
  • site — o nome (à sua escolha) do link.

Tudo que for gravado em site, na verdade, estará sendo gravado em /var/www/html/.
Os links simbólicos têm coloração diferenciada na listagem de um diretório.
Ao dar o comando ls, os links são exibido em anil (ou azul claro).

captura de tela do terminal com listagem de arquivos e diretórios
Clique, para ver detalhes.

Como remover um link

Desde que o link seja simbólico, a operação de remoção só irá afetar o link. O diretório a que o link se refere permanecerá intacto.
Para remover o link, use o comando de remoção de arquivo normal. Para fazer isto, no exemplo dado acima, fica assim:

rm site

Pode verificar. Só o link foi apagado.