Como verificar e consertar seu sistema de arquivos no Ubuntu

O sistema de arquivos do seu HD pode ter problemas, pelas mais variadas razões. Este artigo é sobre como checar e, se houver erros, corrigi-los, com o comando fsck.
Uma situação típica, em que podem ocorrer, não somente perda de dados, mas danos ao seu sistema de arquivos é a situação de falta de energia.
Você reinicia o sistema e ele pára, pedindo para que você faça o reparo manualmente do seu sistema de arquivos.

Como usar o fsck para reparar o sistema de arquivos

O fsck (file system consistency check — verificação da consistência do sistema de arquivos) é um programa usada para encontrar erros no sistema de arquivos e corrigi-los.
Enquanto ferramenta de manutenção da integridade dos seus dados, é bom usá-la com frequência – especialmente em caso de o seu sistema ser desligado de forma irregular.
Para usar o fsck, em um ambiente seguro, tal como vou descrever aqui, você precisará ter privilégios administrativos.
O comando pode ser executado, como root, sozinho:

fsck

Nestas condições, ele irá perscrutar todas as partições descritas em /etc/fstab.
O modo certo de usar o fsck, contudo, é no Runlevel 1, o modo monousuário. Neste runlevel, o seu PC pode se tornar indisponível para o ambiente gráfico – é o equivalente ao modo de segurança no Windows.
Para reiniciar o sistema no runlevel 1, execute o seguinte comando:

init 1

em, seguida, desmonte a partição em que o fsck será executado.
Se quiser obter uma lista das partições que se encontram montadas e onde estão montadas no seu sistema, use o comando:

cat /etc/mtab

ou para saber exatamente onde está montada a sua partição /home:

cat /etc/mtab | grep home
/dev/sda3 /home ext3 rw 0 0

(vou usar a partição /dev/sda3, neste exemplo):

umount /dev/sda3

ou pelo seu nome:

umount /home

Agora execute o fsck:

fsck /dev/sda3

Se preferir não ter que responder a todas as perguntas feitas pelo fsck, use o modo -y. Assim, o fsck executará a verificação e aplicará as correções necessárias, sem te importunar com questões técnicas:

fsck -y /dev/sda3

Se houver arquivos danificados e estes forem recuperados pelo fsck, ele os guardará no diretório /home/lost+found
Ao terminar o processo, você pode reiniciar o computador ou apenas montar de volta a partição desmontada:

mount /home

E volte ao runlevel multiusuário:

init 2

Simples, assim.

LEIA TAMBÉM

MySQL: Otimize suas consultas com Query Cache

O QUERY CACHE armazena o texto de uma declaração SELECT junto ao seu resultado, no cliente. Quando uma declaração idêntica é recebida, mais tarde, o servidor apresenta o resultado, já pronto, em vez de fazer o trabalho de pesquisa novamente.
O query cache é compartilhado entre sessões e, portanto, pode ser aproveitado por diversos outros clientes.

Quando o Query Cache pode ser útil?

Imagine um ambiente em que haja múltiplas tabelas, que não sofram muitas mudanças, para as quais o servidor receba várias consultas idênticas. Em uma situação como esta, é mais rápido fornecer a resposta pronta do que pesquisar a mesma coisa várias vezes.
O query cache não retorna dados velhos ou vencidos. Quando as tabelas são alteradas, qualquer entrada relevante no query cache é descartada.
Até as versões atuais do MySQL, há certas limitações:

  • O query cache não funciona em ambiente onde haja múltiplos servidores mysqld atualizando tabelas MyISAM.
  • O query cache não suporta tabelas particionadas e é automaticamente desabilitado nestes casos. Você não pode habilitá-lo nestes casos.

O query cache não é “ciência exata” e sua eficiência pode variar em função da carga de trabalho a que o servidor está submetido.

Como funciona o Query Cache?

Antes de serem executadas, os textos das consultas são comparados aos que já se encontram armazenados no query cache, que é sensível à caixa. Portanto:

SELECT * FROM nome_da_tabela
select * from nome_da_tabela

são duas queries diferentes.
As consultas têm que ser exatamente as mesmas (em cada byte) para serem reconhecidas como idênticas.
Há outros casos em que queries, mesmo idênticas, serão consideradas diferentes:

  • quando usarem bancos de dados diferentes;
  • ao usarem versões divergentes de protocolo;
  • ao ter diferentes default character set.

O cache vai armazenar as queries, inseridas nos casos acima, separadamente.
O cache não vai aceitar queries dentro das seguintes condições:

  • se refere a uma função definida por usuário — User Defined Function ou UDF;
  • em que sejam executadas de dentro de uma stored function, uma trigger ou um evento;
  • se refere a variáveis definidas por usuário ou programas locais;
  • se refere às tabelas dentro dos bancos de dados MySQL, INFORMATION_SCHEMA ou performance_schema;
  • não usa tabelas;
  • usa tabelas temporárias;
  • gera avisos;
  • o usuário não tem privilégios suficientes para sua completa execução;

Agora, que já terminei de explicar como o query cache não funciona, vou tentar explicar aonde ele vai funcionar – o que é bem mais simples.
Antes de entregar o resultado de uma query, o MySQL verifica se o usuário tem privilégios de SELECT referentes aos bancos de dados e tabelas envolvidos. Se não, o resultado armazenado no cache não poderá ser usado.
O query cache também funciona entre transações, quando você estiver usando tabelas InnoDB.
A partir da versão 5.7 do MySQL, o resultado de uma consulta SELECT em uma VIEW será armazenada no cache.

Como configurar

É possível configurar o valor do query cache

  • no terminal do seu sistema, com o comando mysqld;
  • no arquivo de configuração my.cnf (permanentemente);
  • no cliente do MySQL.

Neste texto, vou mostrar como configurar o query cache direto no cliente MySQL. Abra um terminal e autentique-se no servidor:

mysql -u root -p

Dentro do MySQL, verifique se o query cache está disponível:

SHOW VARIABLES LIKE 'have_query_cache';
+------------------+-------+
| Variable_name    | Value |
+------------------+-------+
| have_query_cache | YES   |
+------------------+-------+
1 row in set (0.00 sec)

Para a gente pode brincar, aqui, o valor da variável have_query_cache precisará ser igual a YES, mesmo que o query cache esteja desativado.
Dentro do MySQL ajuste o tamanho do query cache através da definição da variável de sistema query_cache_size:

SET GLOBAL query_cache_size = 40000

Para desabilitar a função, ajuste o valor de query_cache_size para 0. Seja cuidadoso com o tamanho total da variável. As threads precisam trancar o cache durante sua atualização — caches muito grandes ficam mais tempo trancados.

Textos relacionados:
  • O comando SELECT — conheça várias dicas de uso do comando, no MySQL.
  • Data types — os tipos de dados possíveis para criar campos em uma tabela.
  • Storage engines — conheça os mecanismos de armazenamento do MySQL.

Que tamanho usar pro query cache

O manual do MySQL adverte que o tamanho mínimo possível para query_cache_size é 40Kb, para que ele possa alocar suas estruturas.
Já o tamanho adequado depende da arquitetura do seu sistema. Como já foi dito, valores muito altos podem causar mais prejuízos do que benefícios — uma vez que aumentam o tempo em que o cache fica indisponível a cada atualização.
Valores muito pequenos podem causar a exibição de uma mensagem de aviso e o desativamento do query cache. Veja:

SET GLOBAL query_cache_size = 40000;
Query OK, 0 rows affected, 2 warnings (0.01 sec)
SHOW WARNINGS\G
*************************** 1. row ***************************
  Level: Warning
   Code: 1292
Message: Truncated incorrect query_cache_size value: '40000'
*************************** 2. row ***************************
  Level: Warning
   Code: 1282
Message: Query cache failed to set size 39936;
new query cache size is 0
2 rows in set (0.01 sec)

Na última linha da mensagem, o sistema avisa que alterou o valor da variável query_cache_size para 0.
Neste caso, você deve aumentar gradualmente o valor da variável e testar o seu sistema por alguns dias.
O manual da versão 5.7 do MySQL recomenda um valor mínimo de 1000000, para que o query cache consiga guardar um número razoável de resultados de consultas.

screenshot mysql set global query_cache_size
Clique para ampliar

Como criar um arquivo SWAP no Linux

Normalmente as pessoas criam e configuram a sua partição swap, ao instalar o seu sistema.
Até a versão 2.6 do kernel, o uso de uma partição separada para swap trazia melhorias sensíveis de performance.
Atualmente, um arquivo de swap tem a mesma performance que uma partição dedicada. Ainda assim, o uso de uma partição separada é o jeito mais organizado e seguro de fazer a paginação.

LEIA MAIS

Você pode regular o uso do arquivo/espaço de troca (swap space) no Linux com a configuração do swapiness — o que pode trazer um ganho sensível no desempenho do seu sistema.
Leia mais aqui.

Por que eu deveria criar um arquivo de swap

Se você não tem um arquivo ou partição swap, é aconselhável criar um, para que o sistema tenha para onde “transbordar” quando tiver chegado a um certo limite de uso da memória RAM — que é uma situação rara para usuários comuns do Linux.


Por favor, leia Perguntas e respostas sobre o SWAP.
Se você já tem um arquivo ou partição, não há razão para criar outro, a não ser que o espaço atual seja muito pequeno ou você tenha feito algum upgrade de memória no seu sistema – ao hibernar, o Linux grava no swap toda a situação atual da sua memória RAM, entre outras coisas.
Houve um tempo em que se recomendava configurar o tamanho do swap como o dobro do tamanho da memória RAM. Isto não é mais necessário. O Linux, nas mãos de um usuário normal, vai usar o swap, predominantemente, só para hibernar o sistema. Portanto, o tamanho de swap deve acompanhar o tamanho da sua memória RAM.
Como criar uma nova partição é um pouco complicado, criar um novo arquivo de swap pode ser uma solução mais viável. Vou mostrar como fazê-lo a seguir.

Como criar um arquivo de swap no Linux

O procedimento descrito abaixo vale pra qualquer distro Linux. O que se requer, aqui, é que você tenha acesso root ao sistema, ou seja, tenha privilégios administrativos.
O procedimento não funciona em sistemas de arquivos BTRFS.
O processo envolve o uso do comando dd para criar o arquivo swap e o comando mkswap para configurar o swap em um arquivo ou dispositivo independente.

Autenticando-se como administrador (root)

Abra um terminal – no Ubuntu, use a combinação de teclas Ctrl + Alt +T. Nos exemplos, vou usar o comando sudo para executar os procedimentos com privilégios administrativos. Mas, se você preferir, pode entrar como superusuário, através do comando su e suprimir o uso do sudo — é sua escolha.

Como criar um arquivo de armazenamento com o dd

O comando dd tem múltiplas funcionalidades. Pode ser usado, inclusive, para medir a velocidade de leitura/escrita de um dispositivo, bem como, criar um pendrive inicializável com Linux.
Neste caso, vou criar um arquivo de armazenamento, a ser usado como swap, com o tamanho de 512 Mb.
Multiplique o tamanho que você deseja em Megabytes por 1024, para obter o valor a ser usado pelo parâmetro count, conforme o exemplo a seguir.
Note que 512 multiplicado por 1024 é igual a 524288 – e é este número que vou usar no meu exemplo:


sudo dd if=/dev/zero of=/swapfile bs=1024 count=524288

[sudo] password for justincase: 
524288+0 registros de entrada
524288+0 registros de saída
536870912 bytes (537 MB) copiados, 18,417 s, 29,2 MB/s
justincase@JustInCase-Solaris-8:~$

O arquivo swap já está criado. Segue, abaixo, uma explicação do que foi feito:

  • if=/dev/zero — Lê o arquivo /dev/zero, um arquivo especial uma vez que provê todos os caracteres null necessários para construir o arquivo swapfile
  • of=/swapfile — cria o arquivo /swapfile e grava nele o conteúdo de /dev/zero
  • bs=1024 — este parâmetro indica que 1024 blocos deverão ser gravados/lidos por vez
  • count=524288 — limita a quantidade de blocos gravados a este número

Como configurar o seu arquivo de swap

O comando, que segue, configura o seu recém criado arquivo swapfile como sendo um arquivo de swap:


sudo mkswap /swapfile

mkswap: /swapfile: permissões inseguras 0644, sugere-se 0600.
Configurando espaço de swap versão 1, tamanho = 500 MiB (524284 bytes)
nenhum rótulo, UUID=9055d446-c93c-41e7-b500-5da7bffff888

Agora, siga a recomendação de segurança, e altere as permissões do arquivo:


chmod 0600 /swapfile

Para que o seu arquivo swap seja ativado na próxima vez em que você ligar a máquina, é necessário indicar isto no arquivo de sistema /etc/fstab. Abra-o e acrescente a seguinte linha, no final:

/swapfile swap swap defaults 0 0

Grave o arquivo e feche o editor.
Após reiniciar o seu sistema o swap já estará funcionando.

Como verificar se o meu swap está ativado ou não

Use o comando free para verificar a situação geral de uso da memória do sistema, o que inclui o uso do swap:


sudo free -mh

Normalmente, a última linha costuma mostrar informações sobre ele.
Outra forma de verificar o status do swap é inquirir o arquivo /proc/meminfo/:


cat /proc/meminfo | grep -i swap

Como desativar e remover o arquivo de swap do meu sistema

Para desativar o arquivo de swap criado aqui, use o comando:


sudo swapoff /swapfile

Agora remova a linha inserida ao final do arquivo /etc/fstab.
Após reiniciar o sistema, pode apagar o arquivo /swapfile:


sudo rm -vf /swapfile

Se você tiver interesse em apenas reduzir o uso do swap, clique aqui, para saber como fazer isto.

Assinar blog por e-mail

Digite seu endereço de e-mail para assinar este blog e receber notificações de novas publicações por e-mail.

MySQL: Como criar uma tabela a partir de uma declaração SELECT

Frequentemente é útil separar determinados dados de uma tabela e levá-los para uma outra – onde poderão ser analisados com maior atenção. Esta segunda tabela, pode ser criada a partir de dados selecionados da primeira e seus dados podem ser submetidos a testes e posteriormente descartados, sem afetar os dados originais.
MySQL tutorial - como criar uma tabela a partir de um comando SELECT - CREATE TABLE.Você pode usar este recurso em inúmeras situações, inclusive quando deseja evitar que a nova tabela contenha informações sensíveis ou confidenciais, para o uso de outra pessoa ou empresa.
Normalmente, criamos uma nova tabela e, só então, a povoamos com os dados da tabela original, mas isto pode trabalhoso, especialmente se houver muitas colunas envolvidas no processo.
Neste artigo, vou mostrar como inferir a nova estrutura da tabela diretamente de uma declaração SELECT – com os meios que o MySQL já nos oferece.
A sintaxe da declaração é a seguinte:

CREATE TABLE minha_tabela_nova SELECT coluna1, coluna2, coluna4 FROM minha_tabela_original

E isto é tudo.
Como você pode ver, o MySQL vai criar uma nova tabela a partir da estrutura de uma outra, selecionada através do comando SELECT.
Os dados da tabela anterior também serão adicionados, de forma que a nova tabela já “nasce” povoada.

LEIA MAIS:

O procedimento de criação de tabelas através da declaração SELECT não adiciona os índices, entre outras coisas. Contudo, nada impede que você o faça, em seguida. O trabalho duro, já foi feito.

Mysql: O comando SELECT

Você pode usar declarações com o SELECT para obter registros de uma ou mais tabelas, em um banco de dados.
Para refinar o seu resultado, é possível aninhar outras declarações ou incluir funções dentro da declaração original com o SELECT.
Neste texto, vou explicar como usar o comando SELECT do MySQL, através de diversos exemplos práticos.

Vou partir do pressuposto de que você:

Comece por conectar ao MySQL:

mysql -u root -p
Password:

Em seguida, verifique os bancos de dados disponíveis:

SHOW DATABASES;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| biblio             |
| clientes           |
| mysql              |
+--------------------+
10 rows in set (0.48 sec)

No meu caso, vou usar o banco de dados clientes, onde se encontra a tabela projetos, que vou usar nos exemplos:

USE clientes;

Se você quiser, pode baixar a tabela projetos, que é usada nos exemplos deste artigo. Mas isto não é obrigatório – qualquer tabela que você tiver, poderá ser usada. Basta adaptar os exemplos ao seu caso.
Veja o código fontePara baixar a tabela, clique em show source, ao lado da “lupinha” (abaixo). Em seguida, clique no ícone view source, no canto superior direito da janela de código. Copie e cole o código na sua sessão do MySQL.

CREATE TABLE IF NOT EXISTS `projetos` (
  `id_projeto` mediumint(8) unsigned NOT NULL AUTO_INCREMENT,
  `id_cliente` mediumint(9) DEFAULT NULL,
  `nome_projeto` varchar(255) DEFAULT NULL,
  `data_inicio_projeto` varchar(255) DEFAULT NULL,
  `data_fim_projeto` varchar(255) DEFAULT NULL,
  `descr_projeto` text,
  `valor_projeto` mediumint(9) DEFAULT NULL,
  PRIMARY KEY (`id_projeto`)
) ENGINE=InnoDB  DEFAULT CHARSET=latin1 AUTO_INCREMENT=101 ;

INSERT INTO `projetos` (`id_projeto`, `id_cliente`, `nome_projeto`, `data_inicio_projeto`, `data_fim_projeto`, `descr_projeto`, `valor_projeto`) VALUES
(2, 19, 'Daly', '25-09-2013', '09-08-2020', 'dictum mi, ac mattis', 1786199),
(3, 1, 'Morhet', '28-01-2014', '27-11-2016', 'lacus. Quisque imperdiet, erat nonummy', 2777174),
(4, 25, 'New Radnor', '02-05-2013', '02-02-2017', 'feugiat. Lorem ipsum', 1698175),
(5, 21, 'Bologna', '13-11-2013', '22-12-2021', 'in, dolor. Fusce feugiat.', 1556953),
(8, 19, 'Corbais', '07-09-2013', '03-08-2021', 'in, tempus eu,', 1288463),
(9, 23, 'Gols', '02-05-2013', '19-12-2015', 'bibendum sed, est. Nunc', 375503),
(12, 7, 'Santa Flavia', '05-08-2013', '09-04-2020', 'Proin sed turpis nec mauris', 899445),
(13, 27, 'Sobral', '19-11-2013', '16-08-2014', 'tincidunt, nunc ac mattis', 3483467),
(54, 30, 'Casacalenda', '29-11-2013', '18-05-2016', 'a, malesuada id, erat.', 234014),
(55, 20, 'Ponoka', '03-06-2013', '02-01-2020', 'Sed nunc est, mollis', 1230821),
(56, 4, 'Ponoka', '24-03-2014', '10-11-2019', 'elementum at, egestas a,', 1449375),
(57, 7, 'Fuenlabrada', '25-08-2013', '06-07-2017', 'Sed pharetra, felis eget', 2379213),
(58, 15, 'Fairbanks', '23-03-2013', '16-05-2017', 'dis parturient montes, nascetur', 682314),
(59, 27, 'Sobral', '01-10-2013', '12-01-2020', 'eu dolor egestas rhoncus. Proin', 2561842),
(60, 3, 'Boncelles', '26-11-2013', '27-09-2014', 'est ac mattis', 1079850),
(61, 30, 'Caledon', '20-06-2013', '07-05-2018', 'auctor quis, tristique ac, eleifend', 2247869),
(62, 30, 'Caledon', '21-03-2013', '16-04-2014', 'elementum purus, accumsan interdum libero', 1765979),
(63, 5, 'Wedel', '04-04-2013', '21-09-2016', 'Vestibulum ante ipsum primis in', 2474205),
(64, 25, 'Baricella', '16-12-2013', '05-09-2014', 'cubilia Curae; Donec tincidunt.', 2382058),
(65, 10, 'Neath', '29-12-2013', '24-03-2019', 'at risus. Nunc', 1422902),
(66, 1, 'Liers', '22-06-2013', '11-09-2017', 'Aliquam nec enim. Nunc', 470024),
(68, 30, 'Nellore', '25-09-2013', '17-02-2015', 'quam. Pellentesque habitant morbi tristique', 67899),
(69, 2, 'Lourdes', '28-03-2013', '14-04-2020', 'augue id ante', 2538857),
(70, 28, 'Nives', '27-08-2013', '25-12-2014', 'ante dictum mi,', 1784745),
(71, 18, 'Nives', '14-12-2013', '17-09-2021', 'montes, nascetur ridiculus mus. Donec', 1107111),
(72, 28, 'Beigem', '20-01-2014', '08-07-2018', 'lacus pede sagittis augue,', 734517),
(73, 23, 'Lourdes', '24-05-2013', '26-05-2014', 'et ultrices posuere cubilia Curae;', 3489422),
(74, 22, 'Caledon', '23-10-2013', '12-08-2017', 'Integer eu lacus.', 1845447),
(75, 4, 'Herne', '20-12-2013', '11-06-2019', 'bibendum sed, est. Nunc', 626961),
(76, 20, 'Kincardine', '20-10-2013', '02-07-2016', 'hendrerit. Donec porttitor tellus non', 1348843),
(77, 23, 'Ham-sur-Sambre', '24-05-2013', '29-03-2018', 'montes, nascetur ridiculus mus.', 1211441),
(79, 8, 'Vegreville', '08-12-2013', '15-12-2014', 'Cras eget nisi dictum augue', 1120979),
(80, 5, 'Chetwynd', '04-06-2013', '09-01-2019', 'lectus ante dictum', 58747),
(81, 23, 'Laramie', '26-11-2013', '02-06-2016', 'ut odio vel est', 504943),
(82, 24, 'Cabano', '01-08-2013', '20-12-2018', 'per inceptos hymenaeos. Mauris ut', 389426),
(83, 17, 'Warwick', '19-03-2013', '28-05-2017', 'quam, elementum at,', 2832485),
(84, 28, 'Riparbella', '31-12-2013', '14-02-2016', 'accumsan sed, facilisis', 2424741),
(85, 11, 'Sobral', '20-04-2013', '21-05-2015', 'Proin sed turpis', 428474),
(86, 3, 'Assiniboia', '26-03-2013', '14-03-2020', 'mus. Aenean eget magna.', 1050649),
(87, 28, 'Aylmer', '27-03-2013', '07-11-2017', 'congue a, aliquet', 1951523),
(89, 4, 'Moose Jaw', '19-06-2013', '04-10-2015', 'Nulla interdum. Curabitur', 3119981),
(91, 11, 'Regina', '23-03-2013', '09-08-2018', 'netus et malesuada fames ac', 1556143),
(92, 15, 'Dunstable', '09-03-2013', '27-11-2015', 'Integer sem elit,', 395861),
(93, 30, 'Schwalbach', '21-07-2013', '13-05-2017', 'nunc sit amet metus.', 2372941),
(94, 17, 'Saint-Prime', '10-04-2013', '21-10-2016', 'Donec consectetuer mauris id sapien.', 2293366),
(95, 8, 'Munich', '20-09-2013', '31-12-2016', 'cursus non, egestas', 491439),
(96, 22, 'Presteigne', '21-11-2013', '21-03-2019', 'Aliquam nec enim.', 2586221),
(97, 13, 'Caledon', '16-05-2013', '14-08-2021', 'gravida non, sollicitudin a, malesuada', 536721),
(98, 20, 'Cerchio', '12-08-2013', '15-11-2017', 'primis in faucibus orci luctus', 2559437),
(100, 25, 'Cheyenne', '10-08-2013', '01-12-2016', 'dapibus gravida. Aliquam tincidunt, nunc', 1964699);

Exemplos de uso do comando SELECT no MySQL

O exemplo mais básico de uso de uma declaração com SELECT é a usada para ver todas as colunas (os campos com seus conteúdos) de uma tabela.

SELECT * FROM projetos;

Abaixo, você pode ver o resultado do comando (clique no ícone view source, no canto superior direito, para ver melhor).

+-----+------------+------------+----------------------+--------------------+------------------+-------------------------------------------------------------------------+
| id  | id_projeto | id_cliente | nome_projeto         | data_inicio_projeto | data_fim_projeto | descr_projeto                                                           |
+-----+------------+------------+----------------------+--------------------+------------------+-------------------------------------------------------------------------+
|   1 |          1 |        557 | Macklin              | 15-09-2013         | 09-09-2014       | Lorem                                                                   |
|   2 |          2 |        863 | Kent                 | 18-06-2013         | 10-04-2014       | Lorem ipsum dolor sit amet, consectetuer                                |
|   3 |          3 |        192 | Moradabad            | 10-04-2013         | 01-05-2014       | Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Curabitur sed |
|   4 |          4 |        671 | Lithgow              | 15-07-2013         | 26-05-2014       | Lorem ipsum dolor sit amet, consectetuer                                |
|   5 |          5 |        440 | Bowden               | 14-12-2013         | 07-03-2014       | Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Curabitur sed |
+-----+------------+------------+----------------------+--------------------+------------------+-------------------------------------------------------------------------+
5 rows in set (0.14 sec)

O símbolo * significa all ou todas as colunas, neste caso.
Você pode especificar quais colunas, exatamente, deseja ver, ao descrevê-las no lugar do *.
No exemplo, abaixo, vou pedir para que apenas as colunas id_projeto e nome_projeto sejam exibidas:

SELECT id_projeto, nome_projeto FROM projetos;

E, como resultado, obtenho o seguinte:

+------------+----------------------+
| id_projeto | nome_projeto         |
+------------+----------------------+
|          1 | Macklin              |
|          2 | Kent                 |
|          3 | Moradabad            |
|          4 | Lithgow              |
|          5 | Bowden               |
+------------+----------------------+
10 rows in set (0.01 sec)

Use a função NOW() para obter a data e a hora do servidor MySQL

Obtenha a data e a hora do servidor, através da função NOW():

SELECT NOW();

Há outras funções de data e hora disponíveis para uso no MySQL, de acordo com as suas necessidades.
A função CURDATE(), (CURrrent DATE) retorna apenas a data atual:

SELECT CURDATE();

Refine os resultados da consulta com a cláusula WHERE do MySQL

Ao usar a cláusula WHERE, você indica as condições que os registros têm que satisfazer para serem selecionados.
Veja como exibir id_projetos e nome_projetos, restringindo a relação aos que têm o nome aylmer:

SELECT id_projeto, nome_projeto FROM projetos WHERE nome_projeto = "aylmer";

o que dará o seguinte resultado (para mim):

+------------+--------------+
| id_projeto | nome_projeto |
+------------+--------------+
|         43 | Aylmer       |
|         72 | Aylmer       |
+------------+--------------+
2 rows in set (0.00 sec)

Você pode buscar resultados informando um termo parcial para a busca. Veja como:

SELECT nome_projeto FROM projetos WHERE nome_projeto LIKE 'Mo%';
+--------------+
| nome_projeto |
+--------------+
| Morhet       |
| Moose Jaw    |
+--------------+
2 rows in set (0.00 sec)

O exemplo acima mostra todos nome_projeto, cujo valor comece com Mo. Você pode posicionar o % em outros lugares da string para fazer outras buscas. Experimente.
Para restringir a listagem aos projetos cujos valores superam a cifra de 2500000:

SELECT nome_projeto,valor_projeto FROM projetos WHERE valor_projeto > 2500000;
+-----------------------+---------------+
| nome_projeto          | valor_projeto |
+-----------------------+---------------+
| Morhet                |       2777174 |
| Uppingham. Cottesmore |       3483467 |
| Campbeltown           |       2561842 |
| Prince George         |       2538857 |
| Lourdes               |       3489422 |
| Warwick               |       2832485 |
| Moose Jaw             |       3119981 |
| Presteigne            |       2586221 |
| Cerchio               |       2559437 |
+-----------------------+---------------+

9 rows in set (0.00 sec)
Combine os operadores lógicos para obter resultados ainda mais precisos:

SELECT nome_projeto,valor_projeto FROM projetos WHERE valor_projeto > 2000000 AND valor_projeto < 2500000;
+--------------+---------------+
| nome_projeto | valor_projeto |
+--------------+---------------+
| Fuenlabrada  |       2379213 |
| Caledon      |       2247869 |
| Wedel        |       2474205 |
| Baricella    |       2382058 |
| Riparbella   |       2424741 |
| Schwalbach   |       2372941 |
| Saint-Prime  |       2293366 |
+--------------+---------------+
7 rows in set (0.02 sec)

Ou obter todos os nomes de projetos que sejam iguais a “Caledon” ou que comecem com as letras “Mo”:

SELECT nome_projeto FROM projetos WHERE nome_projeto LIKE 'Caledon' OR nome_projeto LIKE 'Mo%';
+--------------+
| nome_projeto |
+--------------+
| Morhet       |
| Caledon      |
| Caledon      |
| Caledon      |
| Moose Jaw    |
| Caledon      |
+--------------+
6 rows in set (0.00 sec)

Combine valores dos registros e altere a exibição do relatório, com a função CONCAT

Você pode combinar a exibição de valores com a função CONCAT, dentro de um SELECT. Ao usar este recurso, o MySQL cria um novo campo (apenas para exibição), contendo os valores concatenados/combinados.
No exemplo abaixo vou mostrar como combinar os campos nome_projeto e data_inicio_projeto dentro de um novo campo, chamado Detalhes:

SELECT id_projeto, CONCAT('projeto ', nome_projeto, ' iniciado em ', data_inicio_projeto) AS Detalhes, valor_projeto FROM projetos WHERE valor_projeto > 3000000;
+------------+------------------------------------------------------+---------------+
| id_projeto | Detalhes                                             | valor_projeto |
+------------+------------------------------------------------------+---------------+
|         13 | projeto Uppingham. Cottesmore iniciado em 19-11-2013 |       3483467 |
|         73 | projeto Lourdes iniciado em 24-05-2013               |       3489422 |
|         89 | projeto Moose Jaw iniciado em 19-06-2013             |       3119981 |
+------------+------------------------------------------------------+---------------+
3 rows in set (0.00 sec)

Para a lista não ficar muito extensa, no exemplo acima, restringi os projetos a serem exibidos aos que têm valores acima de 3000000.
A lista ficaria melhor, ainda, se as datas fossem exibidas em ordem ascendente:

SELECT id_projeto, CONCAT('projeto ', nome_projeto, ' iniciado em ', data_inicio_projeto) AS Detalhes, valor_projeto FROM projetos WHERE valor_projeto > 3000000 ORDER BY data_inicio_projeto ASC;
+------------+------------------------------------------------------+---------------+
| id_projeto | Detalhes                                             | valor_projeto |
+------------+------------------------------------------------------+---------------+
|         89 | projeto Moose Jaw iniciado em 19-06-2013             |       3119981 |
|         13 | projeto Uppingham. Cottesmore iniciado em 19-11-2013 |       3483467 |
|         73 | projeto Lourdes iniciado em 24-05-2013               |       3489422 |
+------------+------------------------------------------------------+---------------+
3 rows in set (0.00 sec)

Se quiser ler mais sobre a função CONCAT(), clique aqui.

Conte o número de registros dentro de uma tabela com a função COUNT(*)

A função COUNT() realiza a contagem do número de ocorrências dentro da tabela. No exemplo abaixo, a função é usada para contar o número de registros:

SELECT COUNT(*) FROM projetos;
+----------+
| COUNT(*) |
+----------+
|       50 |
+----------+
1 row in set (0.02 sec)

No exemplo, a seguir, vou listar os valores de data_inicio_projeto, agrupar aqueles cujos valores coincidirem e contar quantas vezes se repetem:

SELECT data_inicio_projeto,COUNT(*) FROM projetos GROUP BY data_inicio_projeto;
+---------------------+----------+
| data_inicio_projeto | COUNT(*) |
+---------------------+----------+
| 01-08-2013          |        1 |
| 01-10-2013          |        1 |
| 02-05-2013          |        2 |
| 23-03-2013          |        2 |
+---------------------+----------+
4 rows in set (0.00 sec)

No próximo exemplo, vou restringir mais ainda a lista. Ao combinar o uso de GROUP BY com a função HAVING, vou agrupar e exibir apenas os nome_projeto que se repetirem por 2 vezes ou mais:

SELECT COUNT(*) AS Contagem, nome_projeto FROM projetos GROUP BY nome_projeto HAVING Contagem >= 2;
+----------+--------------+
| Contagem | nome_projeto |
+----------+--------------+
|        4 | Caledon      |
|        2 | Lourdes      |
|        2 | Nives        |
|        2 | Ponoka       |
|        2 | Sobral       |
+----------+--------------+
5 rows in set (0.01 sec)

Altere a exibição dos nomes dos campos na tabela MySQL

Use AS para alterar os nomes de exibição dos campos para outros mais fáceis de entender.
Por diversas questões, uma delas o limite de caracteres, não é possível usar nomes muito grandes nos campos. O fato é que acabam ficando com uma nomenclatura que pode ser de difícil entendimento ou leitura.
Com a função AS, é possível melhorar isto. Veja como:

SELECT id_projeto AS 'Núm. do projeto', nome_projeto AS Projeto, data_inicio_projeto AS Início, valor_projeto AS 'Valor (R$)' FROM projetos WHERE valor_projeto > 2500000;

… e veja como isto muda o aspecto da nossa tabela:

+------------------+-------------+------------+------------+
| Núm. do projeto  | Projeto     | Início     | Valor (R$) |
+------------------+-------------+------------+------------+
|                3 | Morhet      | 28-01-2014 |    2777174 |
|               13 | Sobral      | 19-11-2013 |    3483467 |
|               59 | Campbeltown | 01-10-2013 |    2561842 |
|               69 | Lourdes     | 28-03-2013 |    2538857 |
|               73 | Lourdes     | 24-05-2013 |    3489422 |
|               83 | Warwick     | 19-03-2013 |    2832485 |
|               89 | Moose Jaw   | 19-06-2013 |    3119981 |
|               96 | Presteigne  | 21-11-2013 |    2586221 |
|               98 | Cerchio     | 12-08-2013 |    2559437 |
+------------------+-------------+------------+------------+
9 rows in set (0.00 sec)

A palavra chave AS é opcional. A declaração abaixo tem o mesmo efeito que a anterior:

SELECT id_projeto 'Núm. do projeto', nome_projeto Projeto, data_inicio_projeto Início, valor_projeto 'Valor (R$)' FROM projetos WHERE valor_projeto > 2500000;

Use LIMIT para restringir a quantidade de registros exibidos

Limite a quantidade de registros exibida na tela com a função LIMIT.
Funciona de acordo com a seguinte sintaxe: LIMIT primeiro_registro, qtd_registros.
De forma prática, para exibir os registros de 10 a 15, a declaração ficaria assim:

SELECT * FROM projetos LIMIT 10,5;
+------------+------------+--------------+---------------------+------------------+---------------------------------+---------------+
| id_projeto | id_cliente | nome_projeto | data_inicio_projeto | data_fim_projeto | descr_projeto                   | valor_projeto |
+------------+------------+--------------+---------------------+------------------+---------------------------------+---------------+
|         56 |          4 | Ponoka       | 24-03-2014          | 10-11-2019       | elementum at, egestas a,        |       1449375 |
|         57 |          7 | Fuenlabrada  | 25-08-2013          | 06-07-2017       | Sed pharetra, felis eget        |       2379213 |
|         58 |         15 | Fairbanks    | 23-03-2013          | 16-05-2017       | dis parturient montes, nascetur |        682314 |
|         59 |         27 | Campbeltown  | 01-10-2013          | 12-01-2020       | eu dolor egestas rhoncus. Proin |       2561842 |
|         60 |          3 | Boncelles    | 26-11-2013          | 27-09-2014       | est ac mattis                   |       1079850 |
+------------+------------+--------------+---------------------+------------------+---------------------------------+---------------+
5 rows in set (0.01 sec)

Opcionalmente, você pode omitir o primeiro número. O MySQL vai entender que você deseja começar do registro 0:

SELECT * FROM projetos LIMIT 5;

Use DISTINCT para filtrar informações redundantes

Obtenha apenas os valores diferentes, distintos, na sua relação com a função DISTINCT.
Esta função evita a exibição repetida de campos. Veja o exemplo de uso de uma declaração SELECT sem o DISTINCT e outra com o DISTINCT:

SELECT nome_projeto FROM projetos WHERE nome_projeto = 'Caledon';
+--------------+
| nome_projeto |
+--------------+
| Caledon      |
| Caledon      |
| Caledon      |
| Caledon      |
+--------------+
4 rows in set (0.00 sec)

… e agora, com o DISTINCT:

SELECT DISTINCT nome_projeto FROM projetos WHERE nome_projeto = 'Caledon';
+--------------+
| nome_projeto |
+--------------+
| Caledon      |
+--------------+
1 row in set (0.00 sec)

Realize operações aritméticas básicas com o comando SELECT

Experimente algumas das 4 operações básicas:

SELECT 2 * 3;
+-------+
| 2 * 3 |
+-------+
|     6 |
+-------+
1 row in set (0.00 sec)

Soma de todas os valores em uma coluna

Neste exemplo, vou mostrar a soma de todos os valores da coluna valor_projeto

SELECT SUM(valor_projeto) FROM projetos;
+--------------------+
| SUM(valor_projeto) |
+--------------------+
|           77639864 |
+--------------------+
1 row in set (0.04 sec)

Podemos usar a função AS para tornar o resultado um pouco melhor apresentável, como já vimos anteriormente:

SELECT SUM(valor_projeto) as 'Valor Total' FROM projetos;
+-------------+
| Valor Total |
+-------------+
|    77639864 |
+-------------+
1 row in set (0.03 sec)

Como calcular a média dos valores de uma coluna

Para tirar a média, há uma função chamada AVG() (average):

SELECT AVG(valor_projeto) as 'Média de valores cobrados' FROM projetos;
+----------------------------+
| Média de valores cobrados  |
+----------------------------+
|               1552797.2800 |
+----------------------------+
1 row in set (0.00 sec)

Como arredondar os valores exibidos

Use a função ROUND().
Vamos repetir o exemplo acima para ver como uma função pode aninhar outras funções e produzir um resultado mais agradável:

SELECT ROUND(AVG(valor_projeto),2) as 'Média de valores cobrados' FROM projetos;

Esta declaração faz com que o valor seja arredondado para apenas 2 decimais:

+----------------------------+
| Média de valores cobrados  |
+----------------------------+
|                 1552797.28 |
+----------------------------+
1 row in set (0.00 sec)

Simples, não é?

Como exibir valores monetários

Você já deve ter percebido que a coluna valor_projeto refere-se a um valor monetário. Nesta tabela, os valores estão em 7 dígitos, o que dificulta um pouco sua leitura.
O MySQL tem funções para formatar a exibição de diversos tipos de dados, embora esta não seja sua tarefa. Você deve usar o PHP, o Perl ou qualquer que seja a sua linguagem favorita, para realizar este trabalho.
Mas, já que estamos aqui, vou mostrar rapidamente como exibir os valores da coluna em dólares, usando a função FORMAT() no MySQL:

SELECT nome_projeto "Projeto", FORMAT(valor_projeto,2) "Valor em US$" FROM projetos WHERE valor_projeto > 2700000;
+-----------+--------------+
| Projeto   | Valor em US$ |
+-----------+--------------+
| Morhet    | 2,777,174.00 |
| Sobral    | 3,483,467.00 |
| Lourdes   | 3,489,422.00 |
| Warwick   | 2,832,485.00 |
| Moose Jaw | 3,119,981.00 |
+-----------+--------------+
5 rows in set (0.00 sec)

Use um SELECT dentro de outro SELECT

E, já que o assunto é aninhar funções… vamos ver como aninhar uma declaração SELECT em outra. Embora seja um exemplo um tanto quanto “sem sentido”, a declaração abaixo serve para ilustrar a possibilidade de que falei:

SELECT * FROM (SELECT * FROM projetos WHERE valor_projeto > 2700000) AS Tarefas WHERE id_projeto;

Como gravar o resultado de um SELECT em um arquivo do sistema

Em vez de ver o resultado na tela, você pode direcioná-lo a um arquivo, que pode ser enviado para outra pessoa ou ser trabalhado de outra forma, por outro programa. Veja como fazer isto com o SELECT INTO:

SELECT ROUND(AVG(valor_projeto),2) as 'Média de valores cobrados' INTO OUTFILE '/tmp/média_de_valores_cobrados.txt' FROM projetos;

Para obter um arquivo CSV, do tipo usado na agenda de endereços do seu smartphone – com os campos separados por vírgulas – use a opção FIELDS TERMINATED BY, tal como no exemplo abaixo:

SELECT nome_projeto, valor_projeto INTO OUTFILE '/tmp/valores.csv' FIELDS TERMINATED BY ',' FROM projetos WHERE valor_projeto > 2000000;

Se quiser ver o resultado, basta abrir o arquivo, na pasta /tmp ou em qualquer outro lugar em que você o tenha gravado. O meu ficou assim:

Morhet,2777174
Sobral,3483467
Fuenlabrada,2379213
Campbeltown,2561842
Caledon,2247869
Wedel,2474205
Baricella,2382058
Lourdes,2538857
Lourdes,3489422
Warwick,2832485
Riparbella,2424741
Moose Jaw,3119981
Schwalbach,2372941
Saint-Prime,2293366
Presteigne,2586221
Cerchio,2559437

Como selecionar um registro aleatório dentro da tabela

Para isto, há a função RAND(), com a qual é possível sortear para exibir um registro de dentro da tabela. Isto pode ser útil em casos em que você deseja exibir uma mensagem aleatória, em um site, todo dia.
Veja como ela funciona:

SELECT nome_projeto,valor_projeto,data_fim_projeto FROM projetos ORDER BY RAND() LIMIT 1;
+--------------+---------------+------------------+
| nome_projeto | valor_projeto | data_fim_projeto |
+--------------+---------------+------------------+
| Cabano       |        389426 | 20-12-2018       |
+--------------+---------------+------------------+
1 row in set (0.03 sec)

Ao executar o comando outras vezes, a tendência é que o resultado seja sempre diferente. Experimente.

Como aumentar a prioridade de uma requisição no MySQL

Use a função HIGH_PRIORITY para dar ao SELECT uma prioridade maior que as declarações para atualizar a tabela. A documentação oficial adverte para que esta opção só seja usada em tarefas rápidas e que precisem ser realizadas de uma vez.
Veja como funciona:

SELECT HIGH_PRIORITY * FROM projetos WHERE id_projeto = 12;

LEIA MAIS:

Leia outros artigos sobre MySQL

Você pode clicar nos links, ao longo do texto ou usar o quadro de busca, no canto superior do site.
Há muitos outros artigos sobre MySQL, com exemplos práticos de uso — para você adaptar e aprender mais sobre este sistema de banco de dados.