A sustentabilidade nos negócios é difícil sem uma gestão de dados adequada. Construir um sistema bem definido é essencial para gerir as operações internas e externas. Uma visão detalhada dos dados de negócios ajuda a compreender o fluxo de trabalho geral e a medir o desempenho. Além disso, o uso de bancos de dados poupa tempo e permite aceder à informação sem esforço.
O que é um banco de dados?
Um banco de dados é um sistema organizado utilizado para armazenar informações de forma segura. Ele oferece categorização e permite a criação de tabelas para ordenar tipos semelhantes de itens sob um mesmo grupo. As tabelas oferecem opções para listar informações em várias linhas e colunas. Como resultado, a qualidade e a consistência dos dados melhoram. Além do armazenamento e das capacidades de fácil acesso, os bancos de dados desempenham um papel significativo na salvaguarda da privacidade e na segurança dos sistemas. Seja ad hoc ou parte de um processo codificado em uma aplicação, a recuperação de dados é um dos aspectos mais críticos da gestão de bancos de dados.
Uma consulta em SGBD relacional é qualquer comando usado para recuperar dados de uma tabela. SELECT instruções são quase sempre usadas em Structured Query Language (SQL). Existem vários métodos para recuperar informações de um banco de dados. Geralmente, os desenvolvedores preferem a opção de linha de comando porque é rápida e eficaz. Ela permite enviar consultas de forma integrada.
Neste guia, iremos apresentar-lhe o MySQL e discutir como trabalhar com consultas no MySQL. Vamos começar!
Pré-requisitos
Para acompanhar este tutorial, você precisará do seguinte:
-
A versão mais recente do Ubuntu está instalada no seu sistema.
-
Os usuários do sistema devem ter privilégios sudo.
-
Se você tiver dificuldades para acessar sua conta sudo, considere alterar a MySQL root password.
-
-
O MySQL está configurado no seu servidor.
Passo 1 — Criar e Configurar um Banco de Dados
Antes de começarmos e escrevermos nossa primeira consulta SQL, precisamos criar um banco de dados e adicionar tabelas a ele. Depois disso, iremos preencher as tabelas usando dados de exemplo. Trabalhar com bancos de dados ajudará você a entender a configuração básica e a ganhar confiança ao trabalhar com consultas.
A experiência prática é a maneira mais eficaz de construir conceitos e entender a importância dos bancos de dados. Neste guia, orientaremos você no uso de bancos de dados e na sua importância para resolver problemas do mundo real. Vamos verificar um cenário para entender como os bancos de dados podem ajudar a organizar registros de forma estruturada.
Cenário: Criaremos um banco de dados onde um grupo de estudantes universitários vai sair de férias para comemorar seus aniversários. Antes de irem de férias, eles planejam participar de uma competição amistosa de natação. Além disso, cada amigo do grupo planeja uma lista de tarefas de atividades para tornar a viagem emocionante e agradável.
Primeiro, abra o MySQL como usuário root:
|
1 |
$ sudo mysql |
Em seguida, crie um banco de dados executando o seguinte comando:
|
1 2 3 |
mysql> CREATE DATABASE `vacation`; Query OK, 1 row affected (0.52 sec) |
A seguir, vamos usar nosso banco de dados usando o seguinte comando:
|
1 |
mysql> USE vacation; |
Depois disso, criaremos tabelas no nosso banco de dados. Nomeie a primeira tabela como celebration. Nossa tabela terá colunas para os nomes dos nossos amigos (name), os torneios que eles ganharam (wins) e também uma coluna para o seu melhor tempo (time):
|
1 2 3 4 5 6 7 |
mysql> CREATE TABLE celebration ( -> name varchar(50), -> wins real, -> time real -> ); Query OK, 0 rows affected (2.03 sec) |
Iremos então preencher nossa tabela com dados:
|
1 2 3 4 5 6 7 8 9 |
mysql> INSERT INTO celebration (name, wins, time) VALUES('Austin', '4', '15.5'), ('Ivan','7','9'), ('Aisha','10','5'), ('Zane','13','7.5'); Query OK, 4 rows affected (0.29 sec) Records: 4 Duplicates: 0 Warnings: 0 |
Em seguida, crie outra tabela em nosso banco de dados para armazenar informações sobre suas atividades de aniversário favoritas. Criaremos uma tabela chamada vacation e terá as seguintes colunas:
|
List |
Detail |
|
name: |
Armazena o nome de cada amigo. |
|
birthdate: |
Rastreia a data de nascimento de cada indivíduo. |
|
activity: |
Mantém um registro de sua atividade favorita. |
|
Destination: |
Armazena as informações do destino favorito de cada indivíduo. |
|
meal: |
Rastreia a refeição favorita de que um indivíduo gosta. |
|
1 2 3 4 5 6 7 8 |
mysql> CREATE TABLE vacation ( name varchar(50), birthdate date, activity varchar(50), destination varchar(50), meal varchar(50) ); Query OK, 0 rows affected (0.09 sec) |
Povoe a tabela com dados:
|
1 2 3 4 5 6 7 8 9 10 |
mysql> CREATE TABLE vacation ( name varchar(50), birthdate date, activity varchar(50), destination varchar(50), meal varchar(50) ); Query OK, 0 rows affected (0.09 sec) Records: 4 Duplicates: 0 Warnings: 0 |
Agora você concluiu a configuração do seu banco de dados.
Passo 2 — Primeiros passos com instruções SELECT
As consultas em SQL normalmente começam com SELECT. Ele é usado em consultas para especificar quais colunas de uma tabela devem ser retornadas com os resultados. Uma consulta também deve sempre incluir FROM, que é usado para especificar a tabela que a instrução irá consultar.
As consultas seguem a sintaxe abaixo:
|
1 |
mysql> SELECT column_to_select FROM table_to_select WHERE certain_conditions_apply; |
Usaremos a sintaxe de consulta para retornar a coluna meal da tabela vacation:
|
1 |
mysql> SELECT meal FROM vacation; |
Nossa saída será a seguinte:
|
1 2 3 4 5 6 7 8 9 10 |
+-------+ | meal | +-------+ | Steak | | Sushi | | Fries | | Tofu | +-------+ 4 rows in set (0.00 sec) |
Você também pode selecionar várias colunas usando uma coluna para separá-las:
|
1 |
mysql> SELECT name, destination FROM vacation; |
Saída:
|
1 2 3 4 5 6 7 8 9 10 |
+--------+-------------+ | name | destination | +--------+-------------+ | Austin | Maldives | | Ivan | Mauritius | | Aisha | Colorado | | Zane | Bora Bora | +--------+-------------+ 4 rows in set (0.00 sec) |
Você também pode usar um asterisco (*) se quiser representar todas as colunas da tabela:
|
1 |
mysql> SELECT * FROM celebration; |
Saída:
|
1 2 3 4 5 6 7 8 9 10 |
+--------+------+------+ | name | wins | time | +--------+------+------+ | Austin | 4 | 15.5 | | Ivan | 7 | 9 | | Aisha | 10 | 5 | | Zane | 13 | 7.5 | +--------+------+------+ 4 rows in set (0.00 sec) |
Se quiser filtrar registros que atendam a uma condição especificada, use WHERE. As linhas que não atendem à condição especificada são eliminadas dos resultados. A cláusula WHERE usa a seguinte sintaxe:
|
1 |
mysql> . . . WHERE column_name comparison_operator value |
É um operador de comparação que define como a coluna especificada deve ser comparada com o valor. Os operadores de comparação SQL comuns incluem:
|
Operador |
Uso |
|
= |
Igualdade |
|
!= |
Desigualdade |
|
< |
Menor que |
|
> |
Maior que |
|
<= |
Menor ou igual a |
|
>= |
Maior ou igual a |
|
BETWEEN |
Testa se o valor está dentro do intervalo fornecido. |
|
IN |
Testa se o valor de uma linha está contido em um conjunto de valores especificados. |
|
EXISTS |
Testa se uma linha existe |
|
LIKE |
Testa se um valor corresponde à string especificada |
|
IS NULL |
Testa valores nulos |
|
IS NOT NULL |
Testa todos os valores diferentes de NULL |
Se você quisesse encontrar o destino favorito de Aisha, poderia usar a consulta abaixo:
|
1 |
mysql> SELECT destination FROM vacation WHERE name ='Aisha'; |
A consulta retornará então:
|
1 2 3 4 5 6 7 |
+-------------+ | destination | +-------------+ | Colorado | +-------------+ 1 linha em conjunto (0.03 seg) |
O SQL suporta o uso de caracteres curinga, que são especialmente úteis em WHERE cláusulas. Sinais de porcentagem ( %) denotam zero ou mais caracteres desconhecidos, enquanto sublinhados ( _) denotam um único caractere desconhecido. Estes são úteis se você deseja encontrar uma entrada específica em uma tabela, mas não tem certeza sobre ela.
Por exemplo, se você tivesse esquecido o destino favorito de um amigo e soubesse apenas a letra com a qual ele começa, por exemplo, “m”. Você pode encontrar o nome do destino usando a seguinte consulta:
|
1 |
mysql> SELECT destination FROM vacation WHERE destination LIKE 'm%'; |
A consulta retornará:
|
1 2 3 4 5 6 7 8 |
+-------------+ | destination | +-------------+ | Maldivas | | Maurício | +-------------+ 2 linhas em conjunto (0.04 seg) |
Ao trabalhar com bancos de dados, você pode encontrar colunas ou tabelas com nomes relativamente longos ou difíceis de ler. Nesses casos, você pode tornar os nomes mais legíveis usando a palavra-chave AS para criar um alias. Os aliases criados com AS são válidos apenas durante a execução da consulta para a qual foram criados:
|
1 2 3 4 5 6 7 8 9 10 11 |
mysql> SELECT name AS E, destination as D, activity as A FROM vacation; +--------+-----------+-------------------+ | E | D | A | +--------+-----------+-------------------+ | Austin | Maldivas | esqui | | Ivan | Maurício | parapente | | Aisha | Colorado | montanha escalada | | Zane | Bora Bora | pesca | +--------+-----------+-------------------+ 4 linhas em conjunto (0.00 seg) |
Passo 3 — Introdução às Funções de Agregação
Ao trabalhar com dados, você nem sempre quer ver os dados em si. Em vez disso, prefere ter informações sobre os dados. Ao emitir uma consulta SELECT, você pode interpretar ou executar cálculos em seus dados usando a sintaxe SQL. Elas são chamadas de funções de agregação.
A função COUNT conta e retorna o número de linhas que atendem a um conjunto específico de critérios. Por exemplo, se você quiser saber quantos amigos preferem ir para as Maldivas, você pode usar a seguinte consulta:
|
1 |
mysql> SELECT COUNT(destination) FROM vacation WHERE destination = 'Maldives'; |
Os seguintes resultados serão retornados:
|
1 2 3 4 5 6 7 |
+--------------------+ | COUNT(destination) | +--------------------+ | 1 | +--------------------+ 1 linha em conjunto (0.06 seg) |
MIN é usado para encontrar o menor valor dentro de uma coluna especificada:
|
1 |
mysql> SELECT MIN(wins) FROM celebration; |
A consulta produzirá:
|
1 2 3 4 5 6 7 |
+-----------+ | MIN(wins) | +-----------+ | 4 | +-----------+ 1 linha em conjunto (0.02 seg) |
MAX é usado para encontrar o maior valor numérico em uma determinada coluna:
|
1 |
mysql> SELECT MAX(wins) FROM celebration; |
A saída esperada é:
|
1 2 3 4 5 6 7 |
+-----------+ | MAX(wins) | +-----------+ | 13 | +-----------+ 1 linha em conjunto (0.03 seg) |
Ambas as funções MIN e MAX podem ser usadas em dados numéricos e alfabéticos. Quando aplicada a uma coluna de valores de string, a função MIN retorna o primeiro valor em ordem alfabética.
A função MIN retorna o primeiro valor em ordem alfabética:
|
1 |
mysql> SELECT MIN(name) FROM celebration; |
Aqui está como será a saída:
|
1 2 3 4 5 6 7 |
+-----------+ | MIN(name) | +-----------+ | Aisha | +-----------+ 1 linha em conjunto (0.00 seg) |
A função MAX retorna o último valor em ordem alfabética:
|
1 |
mysql> SELECT MAX(name) FROM celebration; |
Este será o resultado:
|
1 2 3 4 5 6 7 |
+-----------+ | MAX(name) | +-----------+ | Zane | +-----------+ 1 linha em conjunto (0.00 seg) |
Passo 4 — Manipular os Resultados das Consultas
Outra cláusula popular que é utilizada é a GROUP BY cláusula. É usada ao realizar uma função de agregação em uma coluna, mas em relação a valores correspondentes em outra:
|
1 |
mysql> SELECT COUNT(name), activity FROM vacation GROUP BY activity; |
O resultado será:
|
1 2 3 4 5 6 7 8 9 10 |
+-------------+-------------------+ | COUNT(name) | activity | +-------------+-------------------+ | 1 | esqui | | 1 | parapente | | 1 | escalada de montanha | | 1 | pesca | +-------------+-------------------+ 4 linhas em conjunto (0.04 seg) |
Para ordenar os resultados da consulta, utilize a ORDER BY cláusula. Os valores numéricos são ordenados de forma crescente por padrão, enquanto os valores de texto são ordenados alfabeticamente. A consulta abaixo lista as name e birthdate colunas, mas ordena os resultados por birthdate:
|
1 |
mysql> SELECT name, birthdate FROM vacation ORDER BY birthdate; |
O resultado será o seguinte:
|
1 2 3 4 5 6 7 8 9 10 |
+--------+------------+ | name | birthdate | +--------+------------+ | Zane | 1996-01-01 | | Aisha | 1999-07-24 | | Austin | 2002-01-07 | | Ivan | 2010-12-18 | +--------+------------+ 4 linhas em conjunto (0.04 seg) |
O resultado está em ordem crescente; para ordenar em ordem decrescente, termine a consulta com a palavra DESC:
|
1 |
mysql> SELECT name, birthdate FROM vacation ORDER BY birthdate DESC; |
Dê uma olhada no resultado:
|
1 2 3 4 5 6 7 8 9 10 |
+--------+------------+ | name | birthdate | +--------+------------+ | Ivan | 2010-12-18 | | Austin | 2002-01-07 | | Aisha | 1999-07-24 | | Zane | 1996-01-01 | +--------+------------+ 4 linhas em conjunto (0.00 seg) |
A HAVING cláusula foi adicionada ao SQL para fornecer uma funcionalidade semelhante à da WHERE cláusula, sendo também compatível com funções de agregação. A diferença entre estas duas cláusulas é que WHERE serve para se referir a registros individuais e HAVING refere-se a registros de grupo. Para esse fim, a cláusula GROUP BY deve estar presente sempre que uma cláusula HAVING for utilizada:
|
1 |
mysql> SELECT COUNT(name), activity FROM vacation GROUP BY activity HAVING COUNT(name) >= 1; |
A consulta produzirá o seguinte resultado:
|
1 2 3 4 5 6 7 8 |
+-------------+-------------------+ | COUNT(name) | activity | +-------------+-------------------+ | 1 | esqui | | 1 | parapente | | 1 | escalada de montanha | | 1 | pesca | +-------------+-------------------+ |
O COUNT é 1 em todos porque não há dois amigos que gostem da mesma atividade.
Passo 5 — Consultar Múltiplas Tabelas
A JOIN cláusula pode ser utilizada no resultado de uma consulta para combinar linhas de duas ou mais tabelas. Ela faz isso localizando uma coluna relacionada entre as tabelas e ordenando o resultado de forma apropriada.
SELECT instruções que incluem uma JOIN cláusula seguem a sintaxe abaixo:
|
1 2 3 |
mysql> SELECT table1.column1, table2.column2 mysql> FROM table1 mysql> JOIN table2 ON table1.related_column=table2.related_column; |
Se quisesse comprar um troféu para cada um dos seus amigos pelas suas vitórias enquanto nadavam nos seus aniversários, poderia criar uma consulta que juntará ambas as tabelas para o ajudar a encontrar toda a informação que deseja com uma única consulta:
|
1 2 3 |
mysql> SELECT celebration.name, celebration.wins, vacation.birthdate FROM celebration JOIN vacation ON celebration.name=vacation.name; |
A saída será:
|
1 2 3 4 5 6 7 8 9 10 |
+--------+------+------------+ | name | wins | birthdate | +--------+------+------------+ | Austin | 4 | 2002-01-07 | | Ivan | 7 | 2010-12-18 | | Aisha | 10 | 1999-07-24 | | Zane | 13 | 1996-01-01 | +--------+------+------------+ 4 linhas em conjunto (0.00 seg) |
Esta é uma cláusula JOIN interna. Isso ocorre porque ela seleciona todos os registros que possuem valores correspondentes em ambas as tabelas e os exibe em um conjunto de resultados. Os registros que não correspondem à consulta não são incluídos. Podemos incluir uma nova linha em nossas tabelas que não corresponda a nenhuma entrada:
|
1 2 3 4 |
mysql> INSERT INTO celebration(name,wins,time) VALUES('Ella', '1', '120'); Query OK, 1 linha afetada (0.01 seg) |
|
1 2 3 4 |
mysql> INSERT INTO celebration(name,wins,time) VALUES('Ella', '1', '120'); Query OK, 1 linha afetada (0.01 seg) |
Em seguida, execute novamente a instrução SELECT com a cláusula JOIN:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
mysql> SELECT celebration.name, celebration.wins, vacation.birthdate -> FROM celebration -> JOIN vacation ON celebration.name=vacation.name; +--------+------+------------+ | name | wins | birthdate | +--------+------+------------+ | Austin | 4 | 2002-01-07 | | Ivan | 7 | 2010-12-18 | | Aisha | 10 | 1999-07-24 | | Zane | 13 | 1996-01-01 | +--------+------+------------+ 4 linhas em conjunto (0.00 seg) |
Como a tabela celebration não possui nenhuma entrada para Peter e a tabela vacation não possui nenhuma entrada para Ella, esses registros estão ausentes.
Podemos retornar todos os registros de uma das tabelas usando uma cláusula JOIN externa. Isso pode ser um LEFT JOIN ou um RIGHT JOIN. Um LEFT JOIN retorna todos os registros da tabela à esquerda e apenas os registros correspondentes da tabela à direita. A tabela à esquerda no contexto de junções externas é aquela referenciada pela cláusula FROM, e a tabela à direita é qualquer tabela referenciada após a instrução JOIN.
Execute a consulta novamente, mas use uma cláusula LEFT JOIN:
|
1 2 3 |
mysql> SELECT celebration.name, celebration.wins, vacation.birthdate FROM celebration LEFT JOIN vacation ON celebration.name=vacation.name; |
O comando retornará todos os registros da tabela à esquerda ( celebration) mesmo que ela não tenha um registro correspondente na tabela à direita. Quando não houver um registro correspondente na tabela à direita, ele será retornado como NULL:
|
1 2 3 4 5 6 7 8 9 10 11 |
+--------+------+------------+ | name | wins | birthdate | +--------+------+------------+ | Austin | 4 | 2002-01-07 | | Ivan | 7 | 2010-12-18 | | Aisha | 10 | 1999-07-24 | | Zane | 13 | 1996-01-01 | | Ella | 1 | NULL | +--------+------+------------+ 5 linhas em conjunto (0.00 seg) |
Esta é agora a cláusula RIGHT JOIN:
|
1 2 3 |
mysql> SELECT celebration.name, celebration.wins, vacation.birthdate FROM celebration RIGHT JOIN vacation ON celebration.name=vacation.name; |
Todos os valores da tabela à direita serão retornados (vacation). Como o birthdate de Peter está registrado na tabela à direita e não na tabela à esquerda, as colunas name e wins retornarão valores NULL nessas linhas:
|
1 2 3 4 5 6 7 8 9 10 11 |
+--------+------+------------+ | nome | vitórias | data de nascimento | +--------+------+------------+ | Austin | 4 | 2002-01-07 | | Ivan | 7 | 2010-12-18 | | Aisha | 10 | 1999-07-24 | | Zane | 13 | 1996-01-01 | | NULL | NULL | 1991-05-03 | +--------+------+------------+ 5 linhas no conjunto (0.01 seg) |
Você pode usar a cláusula UNION em vez de JOIN para consultar registros de várias tabelas. O operador UNION difere da cláusula JOIN no sentido de que ele combina os resultados de duas instruções SELECT em uma única coluna, em vez de imprimir resultados de várias tabelas como colunas exclusivas usando uma única instrução SELECT.
Você pode executar esta consulta para ilustrar:
|
1 |
mysql> SELECT name FROM celebration UNION SELECT name FROM vacation; |
A consulta remove entradas duplicadas. Este é o comportamento padrão do operador UNION:
|
1 2 3 4 5 6 7 8 9 10 11 12 |
+--------+ | nome | +--------+ | Austin | | Ivan | | Aisha | | Zane | | Ella | | Peter | +--------+ 6 linhas no conjunto (0.00 seg) |
Para retornar todas as entradas (além das duplicadas), use o operador UNION ALL:
|
1 |
mysql> SELECT name FROM celebration UNION ALL SELECT name FROM vacation; |
Saída:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
+--------+ | nome | +--------+ | Austin | | Ivan | | Aisha | | Zane | | Ella | | Austin | | Ivan | | Aisha | | Zane | | Peter | +--------+ 10 linhas no conjunto (0.00 seg) |
As subconsultas são outro método para consultar várias tabelas. Subconsultas são consultas que estão contidas dentro de outra consulta (também conhecidas como consultas internas ou aninhadas). Elas são úteis quando você deseja comparar os resultados de uma consulta com os resultados de uma função de agregação separada.
Usaremos o exemplo de tentar descobrir qual amigo ganhou mais torneios de natação do que Ella. Em vez de consultar quantas partidas Ella ganhou e depois executar outra consulta para ver quem ganhou mais jogos do que isso, você pode calcular ambos com uma única consulta:
|
1 2 3 4 |
mysql> SELECT name, wins FROM celebration -> WHERE wins > ( -> SELECT wins FROM celebration WHERE name = 'Ella' -> ); |
A consulta retornará:
|
1 2 3 4 5 6 7 8 9 10 |
+--------+------+ | nome | vitórias | +--------+------+ | Austin | 4 | | Ivan | 7 | | Aisha | 10 | | Zane | 13 | +--------+------+ 4 linhas no conjunto (0.06 seg) |
Se você quisesse levar seus amigos em uma viagem de férias surpresa, poderia usar uma consulta para ver quem tem mais vitórias e retornar o destino deles:
|
1 2 3 4 |
mysql> SELECT name, destination, activity, meal -> FROM vacation -> WHERE name = ( SELECT name FROM celebration -> WHERE wins = (SELECT MAX(wins) FROM celebration)); |
A consulta retornará:
|
1 2 3 4 5 6 7 |
+------+-------------+----------+------+ | nome | destino | atividade | refeição | +------+-------------+----------+------+ | Zane | Bora Bora | pesca | Tofu | +------+-------------+----------+------+ 1 linha no conjunto (0.00 seg) |
Esta instrução contém uma subconsulta dentro de uma subconsulta.
Conclusão
A geração de consultas é uma das tarefas mais comuns no gerenciamento de bancos de dados. Existem várias ferramentas de administração de banco de dados como phpMyAdmin e pgAdmin que você pode usar para trabalhar com consultas e visualizar seus resultados. No entanto, a instrução SELECT a partir da linha de comando é a escolha preferida devido à sua facilidade de uso e excelente controle.
Além disso, existem muitos tutoriais sobre bancos de dados que você pode explorar em nosso blog:
- SQLite vs MySQL vs. PostgreSQL: Sistemas de Gerenciamento de Banco de Dados Relacionais Comparados
- Soluções Rápidas para Reparar Tabelas Corrompidas no MySQL: Um Tutorial
- Como Instalar o MySQL no Centos 7
- Usuário MySQL — Criar e Conceder Permissões
- Configurando Replicação no MySQL no Ubuntu
Feliz Computação!
Comentários
Nenhum comentário ainda. Seja o primeiro.