Como formatar verticalmente as saídas das queries no MySQL

Quando a saída das suas consultas MySQL aparenta estar muito longa (ou larga), é sempre possível reorganizar as informações verticalmente, o que torna a lista mais extensa por um lado — e mais legível por outro.
logo do mysql sobre tela exibindo resultados de uma query
O principal motivo para usar esta formatação é evitar uma apresentação muito “bagunçada” dos seus dados na tela.
* Pessoalmente, esta formatação me lembra as listagens do dBase III, quando comecei a brincar com bancos de dados 😉
Algumas queries têm resultados tão extensos que ocupam mais de uma linha, na listagem. Isto pode tornar a leitura e a compreensão dos dados mais difícil.

select * from clientesEstaduais;

exemplo de exibição de uma query consulta MySQL
A proposta deste post é reorganizar a saída em um outro formato.
Isto pode ser feito adicionando o parâmetro \G ao comando de consulta. Veja:

SELECT * FROM clientesEstaduais\G;
*************************** 1. row ***************************
         id: 9999
nomecliente: Alea N. Valenzuela
     estado: M
     cidade: Cork
*************************** 2. row ***************************
         id: 10006
nomecliente: Wyatt E. Merritt
     estado: Akwa Ibom
     cidade: Uyo
*************************** 3. row ***************************
         id: 10013
nomecliente: Brenda X. Jefferson
     estado: Provence-Alpes-Côte d'Azur
     cidade: Toulon
*************************** 4. row ***************************
         id: 10020
nomecliente: Dolan Y. Joyner
     estado: CE
     cidade: Maranguape
*************************** 5. row ***************************
         id: 10027
nomecliente: Richard D. Bass
     estado: Karnataka
     cidade: Bijapur

...

Experimente isto com suas próprias queries.

Como executar a query direto da linha de comando

Usuários Linux podem fazer o mesmo direto da linha de comando do seu sistema. Abra um terminal e experimente:

mysql -u root -p -e "SELECT * FROM clientesEstaduais WHERE id>10670\G" tutorial

No comando, acima, fazemos o login como root e executamos a query SELECT * FROM clientesEstaduais WHERE id>10670\G contra o banco de dados tutorial. O meu resultado ficou assim:

Enter password: 
*************************** 1. row ***************************
         id: 10671
nomecliente: Remedios J. Owen
     estado: Alajuela
     cidade: Alajuela
*************************** 2. row ***************************
         id: 10678
nomecliente: Hope U. Houston
     estado: ABR
     cidade: San Giovanni Lipioni
*************************** 3. row ***************************
         id: 10685
nomecliente: Graiden F. Donaldson
     estado: Namen
     cidade: Ligny
*************************** 4. row ***************************
         id: 10692
nomecliente: Petra M. Dejesus
     estado: L
     cidade: Dublin

Se você tiver interesse em compreender melhor como fazer consultas ao banco de dados MySQL direto da linha de comando, leia este artigo.

Como fazer upgrade do MySQL, a partir dos repositórios da Oracle

Ao usar os repositórios oficiais da Oracle, é possível ter uma versão mais atual do MySQL instalada no seu sistema.
O Ubuntu 14.04 LTS vem com a versão 5.5, disponibilizada nos repositórios da Canonical, apesar da Oracle já oferecer a versão 5.6 estável e a versão 5.7, em desenvolvimento, para instalação do repositório MySQL APT.
Oracle and MySQL logos
Fora do ambiente de produção, pode ser interessante ao desenvolvedor ter acesso a uma ferramenta mais atualizada em detrimento da estabilidade.
Neste texto, vou mostrar como fazer o upgrade da versão atual do banco de dados, no Ubuntu para a versão mais nova, adotando os repositórios oficiais da Oracle.
Cabe deixar claro que você deve fazer backup de todos os seus dados importantes, antes de iniciar o processo e que não deve aplicá-lo em máquinas de produção, a menos que você saiba o que está fazendo.
Este tutorial é baseado em uma máquina Ubuntu 14.04 LTS Trusty Tahr, com o MySQL padrão desta distribuição já instalado e rodando. Os procedimentos, a seguir, podem ser aplicados a outras distribuições e versões, com pequenas adaptações.
mysql-apt-repository

Como fazer download do repositório APT do MySQL

O primeiro passo é começar a usar os novos repositórios do MySQL. Note que, depois de executado, os próximos upgrades do MySQL passarão a ocorrer a partir dos repositórios novos e não mais do Ubuntu.
O repositório APT do MySQL suporta as seguintes distros Linux:

  • Debian – 7
  • Ubuntu – 12.04 LTS
  • Ubuntu – 14.04 LTS
  • Ubuntu – 14.10

A partir do repositório MySQL APT será possível instalar as versões mais novas dos seguintes pacotes:

  • MySQL 5.6 (GA)
  • MySQL 5.7 (Development Release ou versão em desenvolvimento)
  • MySQL Workbench 6.2 (GA) – Disponível apenas para Ubuntu
  • MySQL Connector / Python

Para fazer o download da versão apropriada para a sua distro, vá até a página oficial do MySQL: http://dev.mysql.com/downloads/repo/apt/.
Role a página para baixo e escolha a versão de download desejada.
O site vai solicitar o seu login na Oracle. Se você ainda não tiver uma conta, crie uma e depois volte e faça o download.
Dependendo da sua conexão, os arquivos serão baixados em segundos.

Como instalar e configurar o repositório APT do MySQL

A depender da configuração do seu sistema, é possível que o Ubuntu Software Center seja ativado, logo após o download e se proponha a fazer toda a instalação pra você. Se preferir, use este método — ou saia do aplicativo e siga o procedimento, descrito abaixo.


Se quiser verificar a versão atual do MySQL, antes de prosseguir, use o seguinte comando:

mysql --version
mysql Ver 14.14 Distrib 5.5.40, for debian-linux-gnu (x86_64) using readline 6.3

Ainda no terminal, instale o pacote recém baixado:

sudo dpkg --install mysql-apt-config_0.3.2-1ubuntu14.04_all.deb

Adéque o nome do pacote, na linha de comando acima, ao que você baixou.
O dpkg vai iniciar o processo de instalação do repositório APT do MySQL.
Na primeira tela, escolha qual dos pacotes deverá ser instalado.

mysql-apt-config opções de instalação
Clique para ver detalhes.

A seguir, escolha a versão que você deseja instalar.
seleção da versão do mysql
Clique para ver detalhes.

Você pode repetir o mesmo procedimento para cada um dos aplicativos relacionados na primeira tela.
Ao final, selecione Apply e Ok.
Se quiser voltar ao aplicativo para alterar as configurações, use o seguinte comando:

sudo dpkg-reconfigure mysql-apt-config

Como atualizar o MySQL

O próximo passo consiste em aplicar as configurações feitas — e permitir que o sistema faça as atualizações.

sudo apt-get update

Aguarde o update e inicie a instalação dos aplicativos desejados.

sudo apt-get install mysql-server

Se você quiser também atualizar o Workbench, use o apt-get:

sudo apt-get install mysql-workbench

Para verificar se tudo está instalado e funcionando, o comando abaixo mostra o status e a versão instalada do MySQL:

sudo service mysql status
 * MySQL Community Server 5.7.5-m15 is running

Como você pode ver, acima, optei pela developer version.

Referências

Guia de instalação e uso do repositório APT MySQL — http://dev.mysql.com/doc/mysql-apt-repo-quick-guide/en/.

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.

Como baixar e instalar o banco de dados Redis

O Redis é um banco de dados orientado a documentos (document-oriented, projetado para armazenar, recuperar e gerenciar informações também orientadas a documentos – também conhecidas como dados semi-estruturados.
logo redis banco de dados nosqlBancos de dados orientados a documentos constituem uma das muitas categorias dos conhecidos bancos NoSQL.
O Redis é software de código aberto, distribuído sob a licença BSD e vem sendo desenvolvido desde 2009. É construído na linguagem ANSI C e está disponível para diversas plataformas.

Como baixar e instalar

Vamos primeiro baixar a versão estável do Redis e, em seguida iniciar o processo de instalação, que serve para qualquer sistema operacional.
Baixe com o wget:

wget http://download.redis.io/redis-stable.tar.gz

Descompacte o pacote baixado no diretório em que você deseja instalar o Redis:

tar xvzf redis-stable.tar.gz

Entre no diretório do Redis, recém criado:

cd redis-stable

Vamos iniciar o processo de compilação:

make

O aplicativo recomenda rodar o seguinte comando:

make test

Os binários, já compilados, se encontram no diretório src/ – onde você vai encontrar o servidor Redis src/redis-server. Ponha-o pra funcionar:

src/redis-server &

Você deve ver surgir algo semelhante a isto na sua tela:

[18111] 17 Feb 16:35:20.099 # Warning: no config file specified, using the default config. In order to specify a config file use src/redis-server /path/to/redis.conf
[18111] 17 Feb 16:35:20.104 # Unable to set the max number of files limit to 10032 (Operation not permitted), setting the max clients configuration to 3984.
[18111] 17 Feb 16:35:20.105 # Warning: 32 bit instance detected but no memory limit set. Setting 3 GB maxmemory limit with 'noeviction' policy now.
                _._                                                  
           _.-``__ ''-._                                             
      _.-``    `.  `_.  ''-._           Redis 2.8.6 (00000000/0) 32 bit
  .-`` .-```.  ```\/    _.,_ ''-._                                   
 (    '      ,       .-`  | `,    )     Running in stand alone mode
 |`-._`-...-` __...-.``-._|'` _.-'|     Port: 6379
 |    `-._   `._    /     _.-'    |     PID: 18111
  `-._    `-._  `-./  _.-'    _.-'                                   
 |`-._`-._    `-.__.-'    _.-'_.-'|                                  
 |    `-._`-._        _.-'_.-'    |           http://redis.io        
  `-._    `-._`-.__.-'_.-'    _.-'                                   
 |`-._`-._    `-.__.-'    _.-'_.-'|                                  
 |    `-._`-._        _.-'_.-'    |                                  
  `-._    `-._`-.__.-'_.-'    _.-'                                   
      `-._    `-.__.-'    _.-'                                       
          `-._        _.-'                                           
              `-.__.-'                                               

[18111] 17 Feb 16:35:20.108 # Server started, Redis version 2.8.6
[18111] 17 Feb 16:35:20.108 # WARNING overcommit_memory is set to 0! Background save may fail under low memory condition. To fix this issue add 'vm.overcommit_memory = 1' to /etc/sysctl.conf and then reboot or run the command 'sysctl vm.overcommit_memory=1' for this to take effect.
[18111] 17 Feb 16:35:20.108 * The server is now ready to accept connections on port 6379

Usando o Redis

Para “desocupar” o terminal com as mensagens do servidor, pressione Enter. Em seguida, inicie o cliente Redis:

src/redis-cli

Digite os primeiros comandos:

127.0.0.1:6379> set variavel "bom dia"
OK
127.0.0.1:6379> get variavel
"bom dia"
127.0.0.1:6379> 

Para finalizar o cliente Redis use o comando:

quit

Para finalizar o servidor Redis, use o killall:

killall redis-server

Fácil, não é? Não esqueça de compartilhar…