LivroSQL

Prévia do material em texto

Jorge Costa Leite Júnior
[ 2 ]
Ficha catalográfica (opcional). 
Caso deseje, a Câmara Brasileira do Livro faz este serviço,
cobrando R$ 25 para associados e R$ 50 para não associados. 
Para saber mais, visite a página:
http://www.cbl.org.br/telas/servicos/sobreFicha.aspx
[ 3 ]
http://www.cbl.org.br/telas/servicos/sobreFicha.aspx
[ 4 ]
Título de capítulo 1.................................................................8
Título de capítulo 2.................................................................9
Título de capítulo n....................................................................10
[ 5 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
Espaço para dedicatória. 
[ 7 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
Introdução
No contexto atual da sociedade, a quantidade de informação e
dados é gigantesca, indo desde meros dados pessoais como
data de nascimento e nome a um conjunto enorme de
informações em fichas e históricos médicos, dados escolares,
censos demográficos, dados registrados em redes sociais na
forma de imagens, sons, vídeos, textos e todo tipo de mídia
capaz de representar alguma informação ou representar
conhecimento. 
Para entender a importância dos bancos de dados, precisamos
primeiro compreender os conceitos básicos que nos conduzem
a toda uma sistemática que partem de dados unitários a todo
conjunto de informação representado, conhecimentos
armazenados e disponibilizados nas diversas fontes de dados. 
Basicamente, boa parte da informação está armazenada em
dispositivos digitais, computadores, servidores, distribuídos em
redes diversas, controlados por sistemas computacionais,
conhecidos, principalmente como sistemas gerenciadores de
bancos de dados (SGBD).
Ao longo deste livro, voltado principalmente para cursos
técnicos, motivo pelo qual a linguagem buscará afastamento do
rigor acadêmico, será concentrado na manipulação de dados
através do SGBD MySQL. Partindo do concreto para o abstrato,
o objetivo aqui é através de exemplos simples e exercícios
práticos ajudar o estudante de informática ou computação a se
[ 8 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
adentrar nessa área de conhecimento importantíssima no
contexto atual da sociedade.
[ 9 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
Bancos de dados
Para começar precisamos entender o que é um dado. Dado é a
menor unidade de informação. Poderíamos dizer que é uma
forma atômica de informação. Por exemplo, numa carteira de
identidade temos um conjunto de dados diversos (data de
nascimento, nome, local de nascimento, data da emissão, etc.).
Cada uma dessas informações isoladamente, representam a
menor unidade de informação possível, e separadamente (e
desassociados) representam valores isolados.
Quando um conjunto de dados se associam com um propósito
como um registro geral expresso numa carteira de identidade,
temos informações sobre uma pessoa. Numa linguagem
simples, dados associados representam uma informação.
Uma pergunta que pode vir a mente é: “então o que é
Conhecimento?”. Essa questão pode ter várias respostas
filosóficas, mas aqui no nosso contexto, conhecimento é como
eu trabalho o conjunto de informações disponíveis para
solucionar uma situação-problema.
Os Bancos de dados ou Base de Dados (BD) são conjuntos de
dados (geralmente armazenados em dispositivos digitais), que
contém informações ou registros sobre coisas, pessoas,
lugares, situações. São organizados de tal forma a sentido ao
conjunto de dados correlacionados. Isso significa que um BD de
uma clínica é completamente diferente de um BD de uma
escola, já que o conjunto de dados e a forma como se
[ 10 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
relacionam, e seu propósito são completamente distintos, pois
os dados ali representam uma realidade do dia a dia
completamente diferente entre uma escola e clínica. Deste
modo não se imagina um banco de dados de propósito geral.
Ainda que, bancos de dados diferentes possam se comunicar
por meio de redes de computadores e trocar dados e
informações entre si para propósitos além dos quais foram
projetados.
Vale ressaltar que todo BD é projetado (ou modelado) de modo
que com um conjunto mínimo de dados se possa dar conta de
se representar uma realidade. Talvez você lembre que nos
exemplos de física, por exemplo, você despreze o vento,
atritos, influência da temperatura e outras variáveis (ou dados)
para calcular a velocidade média de um corpo que se move ou
o tempo de queda de um objeto. Neste sentido, modelar uma
realidade significa selecionar um conjunto mínimo de dados ou
variáveis capazes de dar conta da solução de um problema.
A forma mais comum de um banco de dados ser representado
é na forma de tabelas. Provavelmente você já viu uma tabela
contendo um conjunto de informações como a tabela a seguir:
Tabela 1 – Dados de Pessoas
Nome Idade Sexo
Aline 23 Feminino
Flávia 40 Feminino
Paulo 18 Masculino
[ 11 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
Observe que essa tabela contendo dados de pessoas (nome,
idade, sexo) é dividida em três colunas. Vários autores de livros
de bancos de dados chamam tais colunas de campo ou
atributo. Cada linha da tabela é chamada de registro, que é
onde de fato os dados estão guardados. Outro nome comum
para tabela é ENTIDADE.
Uma Entidade é uma representação de um conjunto de dados
(informações) sobre um determinado conceito de u sistema
modelado. No caso da tabela 1, acima, poderíamos chamar
essa Entidade de PESSOA, uma vez que seu objetivo (didático) é
representar um conjunto de informações de uma ou várias
pessoas. Toda entidade é constituída de atributos (ou variáveis)
que objetivam representar alguma informação unitária
pertinente a um determinado contexto ou realidade modelada.
Uma pergunta que pode surgir é: “basta ter uma tabela ou
planilha para termos um banco de dados?”
A resposta para esta pergunta não é tão simples, mas podemos
ter banco de dados com apenas uma tabela (ou entidade) ou
dezenas delas, dependendo do problema ou situação modelada
para o qual o banco de dados foi projetado. Mas sim, podemos
ter bancos de dados com várias tabelas que se relacionam
entre si com propósitos específicos. Na figura a seguir vamos
ver uma representação de um banco de dados com várias
tabelas.
[ 12 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
Figura 1 – Representação de um modelo de dados com três tabelas.
Daqui em diante, vamos usar o termo tabela como sinônimo de
entidades para facilitar o entendimento dos exemplos a seguir.
Vamos tomar como sinônimos também coluna, campo e
atributo. Na figura 1, temos três tabelas: CLIENTES, FATURAS,
VENDEDORES. A tabela CLIENTES é composta pelos atributos:
idclientes, nome, endereço, cidade, CEP.
Percebam que nesta notação de modelo, temos uma chave ao
lado do atributo idclientes. Neste caso dizemos que este
atributo é um atributo-chave ou uma chave primária.
Geralmente, a chave primária é um atributo que nunca se
repete o valor (do dado) e serve para ser vinculado a outras
informações. No dia a dia, por exemplo o CPF pode ser
considerado um atributo-chave, uma vez que um carro
comprado é vinculado ao CPF do dono, casa, bens etc. Esse
atributo acaba atuando de duas maneiras: a primeira é uma
busca para não duplicidade de dados (duas pessoas não podem
ter o mesmo CPF). Mas por outro lado um mesmo CPF pode ter
vários bens, etc. Observem que na tabela FATURAS temos
também o atributo idclientes, que associa uma ou mais faturas
[ 13 ]
 Aprendendo Banco de Dados com MySQL, por JorgeCosta Leite Júnior
a um cliente. Além disso também temos o atributo
idvendedores que associa aquela fatura ao vendedor
responsável. Se observarmos a tabela VENDEDORES temos
uma chave primária (ou atributo-chave) chamado
idvendedores.
A aparente coincidência aqui é que as chaves primárias das
tabelas CLIENTES e VENDEDORES também estão presentes na
tabela FATURAS. Por associar clientes e vendedores a faturas,
tais chaves têm papel associativos, e como tem origem em
outras tabelas, tais atributos são chamados de chaves
estrangeiras.
Observem que ao lado de cada atributo temos um tipo de
dados definido para aquele atributo. Se você veio de alguma
linguagem de programação anterior, possivelmente já tenha
conhecido os tipos básicos de dados ou variáveis como: Integer,
Boolean, String, Char, Double, Float e outros. Nos BD existem
inúmeros tipos de dados dentre os quais podemos citar:
Tabela 2 – Tipos básicos de dados no MySQL.
Tipo O que representa
Int Números inteiros
Float Números decimais
Date Datas (formato ‘aaaa-mm-dd’)
Time Hora (formato ‘HH:MM:SS’)
Varchar(50) Tipo de texto com até 50 caracteres
TEXT Textos longos
YEAR Ano
[ 14 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
Esses são apenas alguns tipos de dados possíveis. Ao longo
deste livro vamos apresentar tipos diferentes que podem ser
utilizados em diferentes cenários de dados.
Agora você pode estar se perguntando como eu uso isso tudo?
Bem, para acessar os dados de um banco de dados precisamos
usar um programa de computador (software) que gerencie e
manipule o acesso a tais dados. Esses programas são
conhecidos como Sistemas Gerenciadores de Bancos de Dados
– SGBD, cujos objetivos principais são:
1. Separar dados da aplicação cliente, evitando a mistura
de dados e programa, permitindo compartilhamento de
dados
2. Prover uma interface (gráfica normalmente) para que os
usuários possam incluir, alterar, remover ou consultar
dados já armazenados
3. Controlar o acesso aos dados, aumentando a segurança
4. Simplificar ao programador e usuário uma forma de
projetar e visualizar a estrutura de dados (modelo) para
o BD através de ferramentas de gestão, modelagem e
manipulação de dados.
No decorrer deste livro vamos adotar um SGBD para iniciar
nossos conhecimentos sobre bancos de dados e manipulação
de dados. Esse SGBD será o MySQL SERVER1, que é um
gerenciador de banco de dados que utiliza a linguagem SQL
(linguagem estruturada de consulta) para acessar e manipular
dados. É um dos mais populares SGBD do mundo, e tem como
características interessantes sua portabilidade (roda em vários
sistemas operacionais), compatível com várias linguagens de
[ 15 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
programação, trabalha em rede, com excelente desempenho e
estabilidade a baixo custo computacional. Ainda é um software
livre, com curva de aprendizagem baixa, e facilidade no uso, e
grande documentação na internet. Além disso, os recursos do
MySQL o permitem suportar grandes quantidades de dados,
estando ele presente em grandes e sistemas complexos
diversos espalhados pelo mundo.
[ 16 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
Um pouco sobre o uso do MySQL.
Instalação do MySQL 
Para instalação do MySQL é importante seguir as orientações
da documentação oficial e no link de download oficial1. É muito
importante ficar atento aos passos gerais da instalação. O guia
de instalação é bem interativo e é possível que no Windows
algumas bibliotecas sejam requeridas para o processo de
instalação ser bem-sucedido.
Um ALERTA IMPORTANTE é nunca esquecer de definir a senha
do super usuário (administrador do servidor) chamado root na
instalação do programa. Sendo esse o erro mais comum de
instalação. A Figura 2 mostra a tela crítica na instalação. Neste
momento se pode criar outros usuários (não administradores,
inclusive) para acessar recursos limitados do SGBD. Lembrando
que MySQL. ROOT PASSWORD e REPEAT PASSWORD devem ser
idênticas.
Para criar outros usuários basta clicar em ADD USER e uma
janela vai aparecer permitindo a criação desse novo usuário e
seu perfil de acesso, conforme a figura 3.
1Download do MySQL em https://www.mysql.com/downloads/
[ 17 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
Figura 2 – Criação de senha para o administrador root
Figura 3 – Tela de criação de novos usuários
[ 18 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
Caso seja um usuário inexperiente, pode na instalação definir
como um serviço, o MySQL. inicializar junto com o sistema
operacional. Lembrando apenas que será mais um programa
consumindo memória e processamento. Para marcar o MySQL
como um serviço basta marcar a opção CONFIGURE MySQL
Server as Windows Service e a opção Start the MySQL Server
at System Startup conforme figura 4.
Figura 4 – Configurando o MySQL na inicialização do Windows e como um
serviço.
Finalmente após o processo de instalação concluído é possível 
testar com o usuário root e a senha especificada se o servidor 
está instalado e configurado adequadamente, conforme a 
figura 5.
[ 19 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
Figura 5 – Teste de conexão para servidor bem-sucedido
Uso do MySQL
Uma vez instalado e configurado o MySQL, vamos agora passar
utilizar seus recursos. No escopo desse livro vamos trabalhar a
manipulação de dados, portanto não vamos entrar nos
pormenores de modelagem de dados. Vamos focar na
linguagem estruturada de consulta – SQL. Para acessar a área
de acesso ao SQL vamos fazer o seguinte: Vamos buscar o
cliente (software de acesso ao servidor MySQL) chamado
MySQL Workbench. Ele pode ser acessado no menu iniciar
conforme figura 6:
[ 20 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
Figura 6 – Acesso ao MySQL Workbench
Uma vez clicado o ícone vamos para a tela seguinte na qual 
faremos conexão com o servidor (Figura 7).
Figura 7 – Interface inicial do WORKBENCH
Agora se faz necessário abri uma conexão, bastando clicar na
conexão para o usuário root (conexão padrão), ou clicar no
[ 21 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
ícone (+) para adicionar uma nova conexão com nome de
conexão (chamei de “conexao”) e usuário definidos como visto
na figura 8.
Figura 8 – Criação de conexão.
Vale ressaltar que é necessário informar a senha do usuário
usado na conexão. Feito isso a nova conexão está criada. Para
toda conexão ao servidor agora, basta informar a senha do
usuário a ser conectado, e uma vez autenticado (aprovado), a
tela com acesso ao SQL será aberta (figura 9).
[ 22 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
Figura 9 – Ambiente para programação SQL
A figura 9 tem alguns detalhes importantes: A tela em branco
será o local onde os scripts serão executados. À esquerda
temos uma barra lateral contendo dois itens: SCHEMAS
(bancos de dados) e MANAGEMENT (manutenção do servidor).
Basta clicar em cada uma dessas palavras para alternar os
modos. Vamos concentrar nossos esforços nos bancos de
dados (SCHEMAS). Além disso, vamos entender a barra de
ferramentas (figura 10).
Figura 10 – Barra de Ferramentas
[ 23 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
Vamos nos concentrar nos ícones e suas funções:
Ícone Função
Abre uma nova janela em branco para rodar scripts
(programação) SQL
Abre um arquivo salvo com um script gravado em arquivo e
carrega na janela de programação SQL
Função semelhante a anterior
Salva o script em arquivo com a extensão .sql
Servem para rodar scripts na janela de programação SQL. O
primeiro “raio” roda TUDO que está najanela. O segundo com o
símbolo de cursor, roda somente o trecho selecionado
Existem outros ícones e funções que não serão utilizados nos
próximos momentos, portanto só os exploraremos no
momento devido.
Primeiros Comandos
Vamos agora aprender a usar os primeiros comandos básicos 
do SQL. São simples mas importantes. O primeiro comando 
será o SHOW DATABASES; que mostra todos os bancos de 
dados daquele servidor.
[ 24 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
Figura 11-Exibindo os bancos de dados daquele servidor
Para executar esse comando, lembrando que deve terminar
com; temos duas opções: usar o atalho Ctrl+ ENTER ou clicar no
ícone do Flash com o cursor significando que só executará
aquele conjunto de comandos selecionado.
Pronto, agora você já sabe como exibir os bancos de um
servidor. Para selecionar um banco a ser usado na
programação SQL, basta usar o comando:
use nomedobanco;
Isso significa que vou usar o banco de dados cujo nome é
“nomedobanco”. Para ilustrar isto vamos mostrar um exemplo:
[ 25 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
Figura 12 – Usando o banco Sys
No comando acima, após usar o comando adequadamente,
entramos no banco “sys” e lá podemos operar com seus dados.
Aprendemos também que comentários de uma linha em SQL
basta usar o simbolo - - . Podemos usar também comentários
ao estilo do java.
-- isso é um comentário
/* isto também é um comentário */
Agora vamos saber quais são as tabelas do banco que estamos 
conectados. O Comando SHOW TABLES serve a esse propósito.
Figura 13 – Lista de tabelas do banco de dados SYS
[ 26 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
Explorando um banco de dados real
Aprendemos, recentemente, a conectar a um servidor de
banco de dados, a listar os bancos com o comando SHOW
DATABASES; A usar um banco daquele servidor, e listar todas as
suas respectivas tabelas. Agora vamos ampliar um pouco mais
nosso conhecimento usando um banco real chamado
bancotimes2. O modelo de dados contendo tabelas do banco é
dado a seguir:
Figura 14 – Modelo do banco de dados
Nosso modelo é constituído por duas tabelas (TIMES,
JOGADORES) e sabemos que cada time pode ter vários
jogadores, por isto temos a chave estrangeira idtimes na tabela
JOGADORES, fazendo a associação dessas tabelas.
Uma vez que conhecemos o banco e suas tabelas vamos agora
instalar e configurar o banco no servidor. Após o download do
script e o mesmo salvo no seu sistema de arquivos
[ 27 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
(bancotimes.sql), vamos abrir e rodar o script clicando na
pastinha azul (ícone que representa o carregamento de script
em tela).
Figura 15 – Seleção do arquivo a ser carregado
Uma vez selecionado o arquivo e clicando no botão abrir
teremos o seguinte: A tela de script carregada com um banco a
ser criado e alimentado por dados diversos para que possamos
operar os comandos básicos que aprenderemos a seguir.
[ 28 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
Figura 16 – Script de criação do banco com suas tabelas e dados
Para executar o script basta clicar no botão em FLASH. Ele vai
rodar o script, criar o banco, tabelas e preencher com dados
fictícios para práticas a seguir.
Vamos agora usar o banco. Use bancotimes;
Vamos ver quais são suas tabelas? Show tables;
Figura 17 – Após o comando show tables podemos ver as tabelas para
aquele banco.
[ 29 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
Recapitulamos dois comandos, agora vamos aprender um
comando novo. Imagine que você não visse o modelo com as
tabelas, e quisesse saber os atributos de uma tabela. Vamos ver
a tabela times, por exemplo.
Describe times; /* mostra os atributos da tabela times */
Figura 18 – Atributos da tabela Times
Como se vê na figura acima, são exibidos exatamente os
atributos exibidos no modelo da figura 14, agora com algumas
informações adicionais. Sabemos que o atributo idtimes tem
tamanho 10 e é positivo (unsigned). Além disso tem marcado
em KEY (chave) o valor PRI, ou seja, é a chave primária. A
coluna NULL pergunta se aquele atributo pode ficar sem
preenchimento (YES) ou não (NO). Essa informação será
relevante mais adiante.
Agora tente fazer o mesmo comando para a tabela jogadores.
Describe jogadores;
[ 30 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
Depois nos conte o que percebeu.
A pergunta que nos vem agora é: “onde estão os dados?”
Agora que temos um banco de dados preenchido com dados
podemos aprender a brincar com alguns comandos. O primeiro
será selecionar dados.
O comando SELECT – Para selecionar dados
O primeiro comando a ser aprendido para selecionar dados é o 
SELECT. Vamos aprender sua notação básica:
Select * from times; -- seleciona todos os atributos e dados da 
tabela times
Vamos ao resultado:
Figura 19 – Resultado da consulta executada
[ 31 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
Na terminologia, usar o comando SELECT é chamado de
“consultar” na tabela. O uso do * (asterisco) não é
recomendado para grandes quantidades de dados, portanto
deve ser evitado. Sendo assim, podemos selecionar apenas
alguns atributos a serem exibidos como a seguir:
Figura 20 – Selecionando alguns atributos apenas
Observe que o atributo idtimes não é exibido nessa coleção.
Uma pergunta a seguir seria, tem uma forma de filtrar os dados
que quero exibir? Por exemplo: Times que foram fundados
depois de 1900.Nossa pergunta poderia ser formulada assim:
“Mostre todos os times onde ano de fundação seja maior que
1900”
Sendo assim precisamos aprender uma palavra nova: WHERE 
(no bom português, significa “onde”). Traduzindo para nosso 
SQL teríamos:
[ 32 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
Figura 21 – Uso da cláusula WHERE (onde) como filtro
Observe que o time Flamengo saiu da lista, uma vez que sua
fundação é anterior a 1900. Uma pergunta possível é se o
Flamengo deixou de existir no banco de dados. A resposta seria
não. O comando SELECT serve somente para exibir dados. Ele
não apaga dados.
Se minha questão fosse: “Mostre os times cuja fundação é
entre 1900 e 1920”. Agora temos um intervalo fechado para
situações assim podemos usar BETWEEN para intervalos.
Figura 22-Intervalo fechado usando BETWEEN
[ 33 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
Observe que para o comando BETWEEN precisamos de um 
conectivo AND.
where anodefundacao between 1900 and 1920;
O comando acima numa tradução literal, significaria “onde ano 
de fundação está entre 1900 e (AND) 1920.
O comando BETWEEN é ótimo para intervalos fechados.
A cláusula WHERE permite operadores lógicos diversos ( = , !=, 
<>, >, < dentre outros).
Vamos agora selecionar alguns dados de jogadores.
Figura 23 – Alguns dados selecionados de jogadores
[ 34 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
Agora que vimos dados dos jogadores, vamos fazer algumas 
perguntas:
1. Mostre jogadores que ganham mais de 3000 ou menos de 
2000.
Figura 24 – Uso do conectivo OU (OR) na cláusula WHERE
Observe que precisamos usar um conector “ou” para responder
a essa questão. A Cláusula WHERE suporta várias combinações.
2. Mostre os dados do jogador cujo nome seja “jorge”
Figura 25 – Cláusula WHERE com IGUALDADE
[ 35 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
A consulta realizada acima foi uma busca exata pelo nome, por
isso usamos a igualdade. O comando WHERE permite várias
combinações.
Vamos aprender algumas coisas novas: Ordenação. 
Imagine que quero que a lista de jogadores seja por nome em
ordem alfabética.
Figura 26 – Lista de jogadoresordenadas por nome
[ 36 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
Acabamos de aprender o comando ORDER BY, ou “ordernar
por”, usado para ordenações diversas. Caso queiramos a lista
na ordem decrescente (descendente) é só adicionar o sufixo
DESC.
Para exemplificar essa variação vamos mostrar a lista de
jogadores do maior para o menor salário.
Figura 27 – Lista de Jogadores ordenados pelo maior salário
Também é possível fazer uma série de ordenações combinadas.
Muito bom! Agora podemos responder algumas perguntas
básicas usando o que chamamos de funções de agregação:
[ 37 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
a) Contagem de jogadores (total de jogadores)
Figura 28 – Total de jogares (contagem)
Agora para contar os jogadores usamos a função
COUNT(ATRIBUTO). Essa função requer um atributo como
parâmetro, podendo ser qualquer um da tabela. Para melhorar
a exibição de dados usamos um rótulo (aliás) quando usamos o
comando “as total”. Em outras palavras dissemos “pegue esse
resultado e dê um nome de total”. Poderia ser qualquer nome.
b) Maior salário de jogadores
Figura 29 – Maior salário de jogador
[ 38 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
Observe que neste caso precisei especificar exatamente o
atributo que queria o maior valor ao usar MAX(salario). Para o
menor valor usamos a função MIN(salario). Lembrando que
podemos dar qualquer rótulo ou apelido para esse resultado.
c) Salário médio dos jogadores
Figura 30 – Salário médio dos jogadores com AVG (média em inglês)
Aprendemos até aqui as seguintes funções de agregação que 
resumiremos na tabela a seguir:
Função Significado
MAX(atributo) Valor máximo do atributo
MIN(atributo) Valor mínimo do atributo
AVG(atributo) Valor médio do atributo
Count(atributo) Contagem de linhas, independe de atributo
SUM(atributo) Soma todos os valores para aquele atributo
Distinct atributo Lista sem repetir valores para aquele atributo
Vamos agora somar os salários dos jogadores.
[ 39 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
Figura 31 – Soma total dos salários dos jogadores
Finalmente vamos explorar a função DISTINCT que serve para
descartar valores repetidos. Vamos usar um exemplo simples:
Figura 32 - Lista com diferentes salários de jogadores
[ 40 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
Esse exemplo pode parecer controverso, mas se observarmos,
temos 12 jogadores cadastrados com diferentes salários. Como
eu pedi para exibir diferentes salários DISTINCT SALARIO, o
número de resultados caiu, pois foram retirados os registros de
dados com repetições.
Sendo assim, apresentamos as principais funções de
agregações. Com tais funções combinadas com com as
cláusulas WHERE, ORDER BY e outros comandos apresentados
podem trazer soluções a vários problemas e questões.
Exercícios usando SELECT
Usando o modelo e banco de dados bancotimes responda a 
essas perguntas:
1. Mostre nome e ano de fundação dos times, ordenados pelo nome
2. Mostre o valor médio dos times
3. Mostre o nome, salario e data de nascimento de jogadores do mais 
velho para o mais novo
4. Mostre o nome e salário de jogadores que ganham mais de 2000.
5. Mostre o valor total dos times
6. Mostre o nome dos jogadores ordenados por nome decrescente
7. Mostre o valor mais baixo de um time
8. Mostre nome e data de nascimento para jogadores nascidos a 
partir do ano 2000
9. Mostre o total de jogadores que ganham menos de 3000
10. Mostre o maior valor de times
Esse capítulo foi só um aperitivo do comando SELECT, adiante
vamos apresentar mais recursos. Sigamos na leitura.
[ 41 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
Como Modificar dados de um banco?
No capítulo anterior aprendemos um pouco sobre acessar
banco de dados e recuperar (consultar) dados. A pergunta que
nos vem a seguir é como podemos adicionar, modificar ou até
excluir dados de uma tabela?
Para dar continuidade a nosso processo de aprendizagem
vamos conhecer 3 novos comandos: INSERT, DELETE, UPDATE.
O Comando INSERT
O comando INSERT (inserir em português) é o comando básico
para inserir um registro (conjunto de dados) numa tabela. Ele
tem duas sintaxes.
Vamos a sintaxe mais básica:
Insert into TABELA (atributo1, atributo2, atributoN) values
(valor1,valor2,valor3);
No bom português o comando acima seria algo assim: 
“insira na tabela cujo nome é TABELA nos atributos
(atributo1,atributo2, atributoN) os valores
(valor1,valor2, valorN)”
Uma dica antes de inserir dados numa tabela é verificar quais
são seus atributos e restrições de dados. Sendo Assim,
precisamos revisitar o comando DESCRIBE NOMETABELA.
[ 42 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
Cenário 1: Imagine que eu queria acrescentar um novo time,
mas não lembro bem os atributos da tabela. Podemos retomar
isto com o comando DESCRIBE TIMES;
Ao realizar este comando teremos o seguinte:
Figura 33 – Resultado do DESCRIBE TIMES
Um detalhe não tratado antes, que é importante mencionar
aqui é o fato do atributo idtimes ser AUTO_INCREMENT. Essa
informação é relevante, em especial pelo fato deste atributo
ser uma chave primária. Logo a cada novo time inserido,
incrementa-se em 1 o valor do atributo idtimes (do ultimo
inserido). Por que essa informação é importante? A resposta a
essa questão é que se o atributo for auto incremento não
precisamos passar valor. Exemplo de INSERT com
auto_increment:
insert into times (nome,valor,anodefundacao) values
(‘Santos’,4000000,1921);
[ 43 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
Duas observações são importantes aqui: primeiro se observa
que o atributo-chave idtimes não passamos nem o atributo
nem o valor a ser preenchido. A segunda informação é que
todo atributo não numérico deve ser preenchido com aspas
simples, como é o caso do nome do time. Na tabela jogador por
exemplo a data (tipo DATE) é também preenchida entre aspas
simples. Caso a chave não fosse auto_increment, seria
obrigatório passar o atributo e valor para idtimes.
A segunda notação para este comando permite a inserção de
múltiplos registros (linhas) num só comando:
insert into times (nome,valor,anodefundacao) values
(‘Vasco’,5000000,1891),(‘Benfica’,400000,1910),(‘Barcelona’,
100000,1899);
Observe que agora passamos valores na mesma linha de
comandos para os times VASCO, BENFICA e BARCELONA. Como
posso ter certeza que meu comando funcionou? Primeiro,
considere que executei os comandos destacados. Segundo
vamos usar um SELECT para ver o resultado:
[ 44 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
Como se pode observar na listagem acima, os 4 times foram
inseridos com sucesso em dois comandos diferentes. O
primeiro apenas inserindo o SANTOS, e os três demais na
segunda operação.
É importante notar que inseri valores para todos os atributos,
mas poderia evitar aqueles cujo o preenchimento não fosse
obrigatório, como por exemplo os atributos VALOR e
ANODEFUNDACAO.
Mas como eu posso inserir dados para um jogador? A ideia é
basicamente a mesma, apenas com um detalhe: temos uma
chave estrangeira na tabela jogadores. A chave é idtimes, ela
garante que eu não possa ter um jogador não associado a um
time.
Vimos que o maior idtimes existente é 8. Ou seja, se eu tentar
passar um valor não existente de idtimes na tabela TIMES, o
MySQL. bloqueará o INSERT dando mensagem de erro.
Vamos tentar provocar esse erro:
insert into jogadores (nome,salario,datanascimento,idtimes) values
(‘Captu’,10000,’1999-01-10’,18);
O último parâmetro desse comando é IDTIMES e estou
passando um valor 18. Já sabemos que não existe nenhum time
com esse ID. Logo teremos um erro aqui.
Outraobservação é o padrão de data no formato ‘AAAA-MM-
DD’, ou seja ano, mês, dia.
[ 45 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
A mensagem de erro principal aqui é:
Error Code: 1452. Cannot add or update a child row: a foreign key constraint
fails (`bancotimes`.`jogadores`, CONSTRAINT `jogadores_ibfk_1` FOREIGN
KEY (`idtimes`) REFERENCES `times` (`idtimes`))
Em outras palavras, você está tentando inserir um jogador, cujo
valor de chave estrangeira se refere a um time que não existe.
Sendo assim, muito cuidado com tabelas que possuem chaves
estrangeiras.
O Comando DELETE
O comando delete tem como objetivo excluir uma linha
(registro) ou conjuntos de registro baseados em algum critério
(leia-se tudo que a cláusula WHERE permitir).
A experiência nos ensina, enquanto aprendizes que a melhor
regra de exclusão de dados é pela chave primária.
Por exemplo eu poderia apagar todos os jogadores que tem
salário abaixo de 2000, ou por um nome específico etc. Tais
exclusões são possíveis, mas é bom ser cuidadoso.
Vou explorar aqui os casos nos quais excluímos pela chave
primária. Sendo assim o comando DELETE fica assim:
delete from tabela where chaveprimaria=valor;
[ 46 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
Por exemplo, quero excluir o time Barcelona, e já sei que o
valor da chave primária é 8, logo meu comando seria assim:
delete from times where idtimes = 8;
Essa exclusão ocorreria sem menor problema. Mas imagine
excluir o Bahia, teríamos um problema:
delete from times where nome=’bahia’; - - exclusão sem ser pela chave
Essa exclusão seria permitida, exceto pelo fato de termos 4
jogadores associados ao bahia. Logo teríamos o seguinte erro:
Error Code: 1451. Cannot delete or update a parent row: a foreign key
constraint fails (`bancotimes`.`jogadores`, CONSTRAINT `jogadores_ibfk_1`
FOREIGN KEY (`idtimes`) REFERENCES `times` (`idtimes`))
Em outras palavras, você não pode excluir um time que ainda
tem jogadores associados a ele por chave estrangeira. Acredite,
esse erro é comum, muitas vezes por displicência do
programador SQL.
Portanto, comando DELETE deve observar as associações entre
tabelas e critérios para se evitar danos a base de dados.
O Comando UPDATE
O comando UPDATE serve para atualizar dados de uma linha ou
registro (ou conjunto deles) baseados num critério. Aqui valem
todas as considerações feitas em relação ao DELETE. A sintaxe
básica do update é:
[ 47 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
update nometabela set atributo1 = novovalor1, atributo2 =
novovalor2, atributon = novovalorn where atributo = valor;
A melhor tradução aqui seria: Atualize a tabela “nometabela”
modificando o atributo1 pelo novovalor1, o atributo2 pelo
novovalor2, o atributon pelo novovalorn onde o atributo =
valor.
Recomendo fortemente que o atributo da cláusula WHERE seja
a chave primária, repetindo o alerta relativo ao comando
delete. Vamos para alguns exemplos:
update times set nome= 'Novo Bahia', valor =10000000 
where idtimes = 1;
Esse comando vai alterar o nome do Bahia para Novo Bahia e
seu valor para 10000000. Observe que o update foi feito com o
critério da chave primária.
Figura 34 – Dados do Bahia atualizados
[ 48 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
A despeito de tabelas com chaves estrangeiras, valem as mesmas
recomendações do comando DELETE. Lembrando que você não pode
atualizar uma chave estrangeira cujo valor não exista na tabela de origem
(time por exemplo) como chave primária.
Exercícios
1. Insira um novo time com dados a sua escolha
2. Insira um novo jogador no Flamengo
3. Insira um novo jogador no Vasco
4. Atualize o valor do Vasco para 100000
5. Atualize o nome atual do Bahia para EC Bahia
6. Remova o time inserido na questão 1
7. Remova o jogador inserido na questão 3
8. Remova o jogador KAKA
Exercícios de tradução
Traduza os comandos SQL a seguir:
1. delete from times where nome = ‘Vasco’
2. update jogadores set salario=10000 where idjogadores =3
3. Insert into jogadores (nome, salario,idtimes) values (‘Xuxa’, 4000,1)
4. insert into times (nome, anodefundacao) values (‘Olaria’, 40000)
5. select nome, salario from jogadores where salario > 2000
6. select nome, valor from time where anodefundacao < 1950
7. select nome,salario from jogadores where salario < 400000
8. select distinct nome from jogadores
9. select anodefundacao,nome from times order by nome
10. select max(salario) from jogadores
11. select count(nome) from times
12. select avg(salario) from jogadores where datanascimento > ‘2000-
01-10’
[ 49 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
Criando nossos próprios bancos e tabelas
Aprendemos já a selecionar (consultar) dados, inserir, alterar e
modificar registros. A pergunta agora é como posso criar um
banco de dados, uma vez que um modelo me é apresentado
para meus projetos?
Retomando o modelo dados a seguir:
Figura 35 – Modelo do Banco VENDAS
O modelo acima vamos chamar de banco VENDAS é formado
por 3 tabelas. Uma vez que temos um modelo em mãos, temos
que definir a ordem de criação de tabelas. Essa ordem é
sempre feita prioritariamente com tabelas sem chaves
estrangeiras. Alguns autores chamam essas tabelas de
entidades fortes. Depois delas criadas, vamos criar as que
precisam de menos chaves estrangeiras. No modelo acima,
podemos criar a tabela CLIENTES e VENDEDORES (não
necessariamente nessa ordem) e depois FATURAS, pois essa
tem duas chaves estrangeiras que dependem dessas tabelas.
[ 50 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
Vamos aprender a criar um banco de dados. Para criar um
banco de dados usamos o comando:
CREATE DATABASE NOMEDOBANCO;
Para usar o banco retomamos ao famoso USE NOMEDOBANCO;
Apenas para relembrar, para mostrar as tabelas do banco
usamos o famoso SHOW TABLES;
Vamos agora para o modelo acima, criar o banco e tabelas
respectivas:
Figura 36 – Criação e uso de banco VENDAS, Exibição de tabelas
Esse conjunto de comandos apenas criou no espaço em disco
(ou armazenamento) espaço e estruturas para receber futuras
tabelas que serão criadas. É um banco vazio sem tabelas.
CRIAÇÃO DE TABELAS
Para criar tabelas é necessário definir nome da tabela,
atributos, domínios e regras, chaves e informações adicionais.
Vou proceder a criação da tabela VENDEDORES.
[ 51 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
Toda tabela criada tem a seguinte estrutura:
Create table NOME(
atributo1 tipo nulo ou não, se é autoincremento ou primária,
atributo2 tipo nulo ou não,
atributo3 tipo outras características
chave primária,
chave estrangeira);
Vamos agora criar a tabela vendedores:
Figura 37 – Criação da tabela Vendedores
A figura 37 mostra a aplicação da estrutura básica de criação de
tabelas, no caso específico da tabela VENDEDORES. Observe
que na linha 1, criamos e damos nome a tabela, na linha 2
criamos o atributo idvendedores que é do tipo inteiro positivo
(unsigned), sendo obrigatório (NOT NULL), e finalmente é um
auto incremento, pois será definido como chave primária na
linha 7. Na linha 2, temos o atributo nome (texto) do tipo
VARCHAR(50), o que permite 50 caracteres, sendo obrigatório
(NOT NULL). A Linha 4 tem o atributo datacontratacao do tipo
date, não obrigatório. O Atributo salario, do tipo float tem
valor DEFAULT = 1000, isso significa, que se nenhum valor for
passado, esse valor será assumido no atributo. Comissão
[ 52 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
também é float mas não obrigatório. Finalmente definimos a
chave primária idvendedores.
Já a tabela Clientes segue o modelo da tabela cliente, apenas
com todos os atributos, exceto a chaveprimária como varchar.
Isso é proposital para ajustes futuros na base.
Figura 38 – Criação da tabela CLIENTES
Como dissemos, a ordem de criação das tabelas leva em
consideração que tabelas com menos chaves estrangeiras
devem ser criadas primeiro. Por isso criamos VENDEDORES e
CLIENTES, já que não possuíam chaves estrangeiras. Agora
procederemos a criação da tabela FATURAS.
A tabla FATURAS possui duas chaves estrangeiras idclientes e
idvendedores. Mesmo sendo chaves estrangeiras, precisam ser
criadas como atributos, antes de se fazer atribuição como
chaves estrangeiras. Vamos ao script:
[ 53 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
Figura 39 – Criação da tabela Faturas
O que temos nesta tabela: chave primária idfaturas, o atributo
data do tipo date. Nas linhas 4 e 5 criamos os atributos
idclientes e idvendedores idênticos ao que temos nas tabelas
originais, excetuando-se o auto_increment. Essas linhas só
criam os atributos, mas eles ainda não são chaves. A Linha 6
atribui idfaturas como chave primária desta tabela. As chaves
estrangeiras (FOREIGN KEY) são definidas nas linhas 7 e 8. A
notação básica é dizer o nome do atributo na tabela atual que
será a chave estrangeira. No REFERENCES informar a tabela de
origem e entre parênteses, o nome do atributo na tabela de
origem. Bons modelos geralmente, mantém os nomes das
chaves estrangeiras idênticos aos da tabela de origem.
Finalmente, se dermos um SHOW TABLES, teremos as 3 tabelas
criadas.
Figura 40 – Lista de tabelas criadas
[ 54 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
MODIFICAÇÃO DE ESTRUTURA DE TABELAS
Uma vez criadas nossas tabelas do modelo, agora
materializadas no projeto lógico, é possível que se busque
possíveis ajustes ou alterações nas mesmas.
A primeira delas é apagar a tabela. O comando é simples:
drop table nomedatabela;
Para evitar confusão com o comando delete, assuma que DROP
significa apague a estrutura da tabela.
Caso a tabela tenha dados, e se queira limpar os dados usamos
o truncate.
Truncate table nomedatabela;
Finalmente imaginemos que queremos alterar apenas parte da
estrutura de uma tabela. Essa alteração estrutural (ALTER) tem
4 possibilidades básicas:
1. Adicionar atributo – ADD
2. Remover atributo – DROP
3. Modificar atributo – MODIFY
4. Mudar nome do atributo – CHANGE
Vamos tomar a tabela CLIENTES como exemplo. Observe que
todos os atributos estão como varchar. Vamos fazer alguns
ajustes.
a) Ajuste 1: vamos adicionar o atributo telefone:
[ 55 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
ALTER TABLE CLIENTES ADD TELEFONE Varchar(10);
Esse comando altera a estrutura da tabela cliente adicionando
o atributo TELEFONE que será do tipo varchar(10);
b) Ajuste 2: vamos remover o atributo CEP:
ALTER TABLE CLIENTES DROP CEP;
Esse comando altera a estrutura da tabela cliente removendo o
atributo CEP.
c) Ajuste 3: Vamos trocar o tipo do endereço pra TEXT
ALTER TABLE CLIENTES MODIFY ENDERECO TEXT;
O Modify basicamente altera o tipo de dados e domínio.
d) Ajuste 4: Vamos renomear o atributo cidade para municipio
ALTER TABLE CLIENTE CHANGE ENDERECO MUNICIPIO
VARCHAR(100);
Aqui, além de modificar o nome do atributo ENDERECO para
MUNICIPIO pudemos modificar o tipo para varchar(100).
Finalmente, gostaria de apresentar o tipo ENUM, que serve
para predefinir uma lista de valores a escolha do usuário para
um atributo. Vamos ao exemplo seguir:
sexo ENUM(‘m’,’f’); -- atributo sexo só pode ter os valores ‘m’ ou ‘f’
[ 56 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
É importante mencionar que podemos criar atributos no
momento de criação de tabela com o CREATE TABLE ou através
do ALTER TABLE ADD
Então vamos agora adicionar um atributo sexo para clientes
usando o comando ENUM:
alter table clientes add sexo enum(‘m’,’f’);
Com a execução dos comandos acima, a tabela CLIENTES fica
da seguinte forma:
Figura 41-Tabela CLIENTES após a execução dos comandos ALTER TABLE
Figura 41 – Tabela Clientes após as modificações realizadas
Observe que as modificações nos atributos são bem diversas
das listadas na figura 38. Vale destacar que se a tabela estiver
preenchida com dados, pode haver perda de dados, problemas
de conversão de tipos e outros erros. Portanto é preciso
cautela ao usar ALTER TABLE e suas variantes com o banco de
dados em produção.
[ 57 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
Exercícios de Fixação
1. Liste as tabelas
2. Descreva cada uma das tabelas
3. Adicione o atributo telefone para clientes
4. Modifique o atributo cep para varchar(10)
5. Adicione o atributo sexo para vendedores do tipo ENUM com os
valores ‘F’ ou ‘M’
6. Adicione o atributo hora na tabela fatura. O formato de hora é
‘HH:mm’
7. Remova o atributo inserido na questão anterior
8. Adicione o atributo valor do tipo Double na tabela faturas
9. Renomeie o atributo nome (tabela vendedor) para
“nomevendedor”
10. Modifique o endereço para varchar(200)
11. Adicione um atributo UF com dois caracteres na tabela clientes.
12. Adicione um atributo valor tipo Double na tabela faturas
13. Adicione o atributo CPF na tabela Faturas
14. Remova o atributo CPF da tabela Faturas
15. Altere a comissão na tabela VENDEDORES para Double
16. Modifique o atributo cep para varchar(10)
Parte 2 – Realize as operações a seguir:
1. Insira 4 clientes
2. Insira 3 vendedores
3. Exclua o último cliente inserido
4. Insira uma nova fatura com o primeiro vendedor inserido, e o
segundo cliente
5. Modifique os dados do segundo vendedor
6. Dê um aumento de 20% a todos os vendedores
7. Insira uma nova fatura com o segundo vendedor e o primeiro
cliente
8. Mostre os vendedores do sexo feminino
9. Mostre os valores das faturas do mais alto para o mais baixo
10. Mostre as cidades dos clientes em ordem alfabética
[ 58 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
11. Mostre o valor total em faturas
12. Mostre o menor salário de vendedor
13. Mostre as faturas emitidas entre o ano de 2000 e 2010.
[ 59 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
Ampliando nossos conhecimentos sobre o
Select, Delete, Insert e Update
Aprendemos já a selecionar (consultar) dados, inserir, alterar e
modificar registros. Aprendemos também a criar bancos e
tabelas, verificar sua estrutura e realizar consultas simples.
Vamos agora, exercitar nossos conhecimentos, revisitando os
comandos ora aprendidos e expandi-los com maior
complexidade.
Para ajudar em nossa tarefa, vamos trabalhar com o banco de
dados a seguir (CLINICA2020):
Figura 42 – Tabelas com seus respectivos atributos do banco CLINICA
Nesse banco temos dados de pacientes, médicos, funcionários
doenças, especialidades médicas, ambulatórios, consultas etc.
[ 60 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
O primeiro passo para trabalhar com esse banco é executar seu
script disponível online2.
Figura 43 – Janela com o script a ser carregado e executado
Uma vez executado o script, o banco e tabelas serão criados
com todos os seus dados. Feito isso, vamos numa sequência de
comandos selecionar o banco e exibir as tabelas:
Figura 44 – Usando o banco e exibindo suas tabelas
2Script disponível em:
https://1drv.ms/u/s!AjrvH4IdOLnXgdMpKfzFIxAZyilIaA?e=78YZBf
[ 61 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
Feito isto temos nosso banco criado e vamos examinar algumas
tabelas. Podemos dar um DESCRIBE em cada tabela ou usar um 
SELECT para vermos os dados. Vou mostrar dois exemplos a 
seguir:
Figura 45 – Descrição da estrutura da tabela PACIENTES
Figura 46 - Selecionando todos os dados da tabela PACIENTES para
visualização dos dados.
Novamente faço o alerta que o SELECT * não é recomendável 
para grandes conjuntos de dados.
Agorajá sabemos como ver estrutura e dados de uma tabela
podemos continuar nossa análise do banco CLINICA2020 e
[ 62 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
aprender e ampliar nossos conhecimentos através de exemplos
novos e associando os conceitos aprendidos anteriormente.
Para isto, vamos fazer questionamentos ao banco e apresentar
respostas, por meio de PROBLEMAS:
PROBLEMA 1: Mostrar o nome, sexo e idade dos pacientes
com idade maior que 18 anos.
Figura 47 - Consulta e resultado
Observe que aplicamos o filtro WHERE IDADE > 18. Mas se 
quisermos apenas pacientes do sexo feminino? Basta adicionar 
um conector AND e uma nova condição sexo =’f’. Vejamos a 
seguir:
[ 63 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
Figura 48 – Consulta modificada com a adição da condição do sexo feminino
Podemos combinar numa cláusula WHERE várias condições e 
atributos em consultas.
PROBLEMA 2: Mostrar o total de pessoas por sexo.
Para resolver essa questão precisamos entender que
poderíamos fazer duas contagens (usando Count). Seria um
para cada sexo:
select count(nome) from pacientes where sexo= ‘f’;
select count(nome) from pacientes where sexo= ‘m’;
O problema desta solução é que seriam consultas distintas com
resultados distintos. Mas imagine que fossem 3000 sexos
diferentes possíveis, você teria que fazer 3000 consultas para
atingir esse resultado. Sendo assim, deve haver algum
comando capaz de realizar agrupamentos. Esse comando é o
famoso GROUP BY. Vamos dar um exemplo de uso simples a
seguir:
Figura 49 – Uso do agrupamento por sexo
[ 64 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
Observe que para fazer a contagem usamos o tradicional
count(nome) e demos o apelido de total (as total). No Select
também optamos a exibir o atributo sexo para visualizarmos
para que sexo aquela quantidade (total) está relacionada.
Finalmente, fazemos o agrupamento com o comando group by
sexo. Deste modo, especificamos por qual atributo é esse
agrupamento de dados. Em consultas com a cláusula WHERE, o
group by é sempre depois o filtro da cláusula WHERE. Caso haja
ordenações (order by),o group by é sempre antes da
ordenação. 
PROBLEMA 3: Mostrar a média salarial por sexo para os
funcionários que ganham acima de RS 1000.
Para resolver esse problema vamos trabalhar por similaridade
com a forma de resolução anterior. A função AVG(atributo) nos
fornece a média de um conjunto de valores pra aquele
atributo. Mas além disso queremos mostrar o sexo do
funcionário (agrupamento), desde que seu salário seja superior
à R$ 1000,00 (filtro). Sendo assim nossa resposta exige um
SELECT contendo função de agregação (AVG), filtro (WHERE) e
agrupamento (GROUP BY). Deste modo teríamos a seguinte
resposta:
Figura 50 –
Seleção com uso de agrupamento e filtro
[ 65 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
Poderíamos também caso se fizesse necessário usar ordenação
(order by) para ordenar por algum atributo. Sendo assim,
ampliamos nossos conhecimentos do SELECT com boa parte de
suas nuanças, úteis em vários tipos de problemas.
PROBLEMA 4: Mostrar o total de consultas de um paciente
Para resolver esse problema precisamos entender primeiro,
que por uma questão de modelagem, se prefere guardar o
idpacientes na tabela CONSULTAS. O motivo para isso é para
que se evite o problema de inconsistência nos dados, além de
minimizar o uso recorrente do atributo nome na tabela
CONSULTAS, evitando que o usuário em processos de digitação
para um mesmo nome, digite (de maneira errada ou
despropositais) nome errado para um paciente já cadastrado.
Com o conhecimento anterior adquirido poderíamos pensar
então que a resposta seria algo do tipo:
select idpacientes, count(dia) as total from consultas group by
idpacientes;
[ 66 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
Figura 51 – Total de consultas por paciente
Embora a resposta seja correta, temos um problema novo.
Quem é o paciente cujo idpacientes tem valor 1 ou 3 ou 8?
Uma resposta simples seria fazer a boa e velha consulta básica:
select nome, sexo, idpacientes from pacientes where idpacientes 
=1;
Agora temos uma reposta nova e um problema novo. Como
posso juntar a reposta para essas duas questões em uma única
consulta? Veremos no capítulo a seguir. Aguardem.
PROBLEMA 5: Mostrar os pacientes que tiveram consultas
Para resolver essa questão vamos voltar para a boa e velha
teoria de conjuntos. Já sabemos que o atributo idpacientes
está em dois conjuntos ou tabelas diferentes associadas. Nossa
pergunta, dentro dessa perspectiva se tornaria algo do tipo: 
“Existe idpacientes da tabela PACIENTES que também esteja na
tabela CONSULTAS?”
Para responder essa pergunta teríamos os seguintes conjuntos:
Conjunto A: select nome,sexo, idpacientes from pacientes;
Conjunto B: select idpacientes from consultas;
Então agora vamos fazer a pergunta se temos elementos do
conjunto A em B, usando o operador IN (está ou pertence).
Podemos também usar o operador de negação NOT para
[ 67 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
verificar, por exemplo se esse elemento de A não está em B.
Para finalmente responder a pergunta inicial temos o seguinte:
Figura 52 – Operação de conjuntos (subconsultas)
Como se pode ver na figura acima, o filtro (cláusula WHERE)
serviu para filtrar pelo idpacientes (elemento associativo) para
verificar a pertinência (não) de um elemento de A (o primeiro
select) no subconjunto B (segunda consulta). Observe que a
subconsulta é dada dentro de parênteses.
Caso quiséssemos perguntar quais os pacientes que não tem
consulta, bastaríamos incluir o prefixo NOT antes do IN.
Ficando da seguinte forma.
Select nome,sexo, idpacientes from pacientes where idpacientes
not in (select idpacientes from consultas);
PROBLEMA 6: Mostrar os funcionários cuja idade é maior que
a idade média dos pacientes.
[ 68 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
Aqui agora temos dois conjuntos: o primeiro é o de
funcionários e o segundo a média de idade de pacientes (esse
será um conjunto unitário).
Conjunto A: select nome, idade from funcionarios;
Conjunto B: select avg(idade) as media from pacientes;
Para realizar essa subconsulta, vamos usar o critério de que as
idades do conjunto A tem que ser maior que a média calculada
do conjunto B. Teríamos assim o seguinte:
Figura 53 – Subconsulta com comparador > (maior que) 
Por analogia poderíamos usar os operadores menor que, igual 
ou maior ou menor ou igual.
PROBLEMA 7: Mostrar os pacientes mais novos
Essa resposta pode parecer fácil, pois bastaríamos pegar a lista
de pacientes ordenadas por idade. Boa parte de nós
pensaríamos assim.
[ 69 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
Select nome, idade from pacientes order by idade;
O problema para esta abordagem é que se houver um empate
de idades, a consulta anterior traz uma lista ordenada apenas
mostrando várias idades sem dizer exatamente quem tem a
menor idade. Usando subconsultas teríamos a seguinte
solução:
select nome,idade from pacientes where idade = (select min(idade)
as menor from pacientes);
Agora, finalmente, temos uma listagem na qual somente
teremos pacientes cuja idade seja exatamente a menor idade
registrada. Ou seja, os casos de empate de idade serão
exibidos.
Por analogia poderíamos responder, usando os operadores
lógicos adequados, as seguintes questões:
(a) Pacientes cuja idade seja maior que a média de idades
(b) Pacientes que tenham que não tenham a maior idade
(c) Funcionários que tem salários menores que a média
salarial de médicos
(d) Dentre outras.
PROBLEMA 8: Mostrar as consultasque ocorreram entre
janeiro e maio de 2016.
Como trabalhamos pouco com datas e horas vamos exercitar
essa habilidade. Vale relembrar que o tipo DATE é
representado no padrão ‘aaaa-mm-dd’ e o tipo TIME é
representado no padrão ‘HH:MM’. Sendo assim, podemos
[ 70 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
representar o natal de um ano qualquer, poderíamos assim
representar ‘2010-12-25’, na ordem ANO, MÊS, DIA. Já o
horário de meio dia seria representado por ‘12:00’, hora e
minuto. Vale ressaltar que TIME pode representar também
segundo, ficando da seguinte forma ‘12:00:00’.
Uma vez detalhando esses tipos de dados a resposta a esta
consulta seria:
Figura 54 – Consulta com intervalo de datas
PROBLEMA 9: Mostrar as consultas que ocorreram entre
janeiro e maio de 2016 no turno vespertino.
Esse problema é uma ampliação do anterior, apenas
acrescentando o filtro para o turno vespertino. Vamos assumir
que o turno vespertino é das 14 às 18 h.
[ 71 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
Figura 55 – Consulta com intervalo de datas e filtro de horários
Exercícios de Revisão
1. Mostre todos os médicos que ganham mais que 4000
2. Mostre os médicos com idades entre 20 e 35 anos
3. Mostre o total de funcionários por sexo
4. Mostre o total de funcionários por cidade
5. Mostre todas as consultas realizadas no ano de 2016
6. Mostre a capacidade total de cada ambulatório
7. Mostre o total de médicos por especialidade
8. Mostre os funcionários do sexo feminino que ganham menos de
3000
9. Mostre a média salarial por sexo
10. Mostre o nome das 5 pessoas mais novas
11. Mostre a média salarial por sexo
12. Mostre a idade média por sexo de cada cidade
13. Mostre o total de consultas por médico, realizadas no turno
matutino
14. Mostre a lista de cidades e o total de pessoas de cada sexo
15. Mostre os pacientes que não estão em nenhuma consulta
16. Mostre os nomes de médicos que tem consultas
17. Mostre o nome dos pacientes que tem idades acima da média das
idades
18. Mostre os dados dos médicos que ganham o menor salário
Junções de tabelas 
[ 72 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
No MySQL temos três tipos básicos de junções de tabelas:
1. INNER JOIN
2. RIGHT JOIN
3. LEFT JOIN
Vamos começar pelo INNER JOIN, que equivale a uma
interseção de conjuntos. Isso significa que um elemento deverá
estar nos dois conjuntos de dados (tabelas ou resultados de
consultas). Se observarmos o modelo, temos o atributo
idpacientes nas tabelas PACIENTES e CONSULTAS. Como chave
primária na primeira tabela (vamos chamar de tabela1) e chave
estrangeira na segunda tabela (vamos chamar de tabela 2),
esse atributo serve como forma de associação entre esses
conjuntos de dados. Deste modo, precisamos para todo
processo de junção de tabelas seguir os seguintes passos:
Passos para junções de tabelas:
1. Identificar os atributos e as respectivas tabelas da 
junção (tabela1, tabela2, atributo1, atributo2)
2. Juntar as tabelas com as chaves do relacionamento. 
Exemplo: Tabela1.Chave1 = tabela2.chave1 
3. Aplicar critérios e filtros pela cláusula WHERE, se 
solicitado
4. Agrupamentos, se necessário (GROUP BY)
5. Ordenações, se necessário (ORDER BY)
É importante enfatizar que na junção de tabelas se faz
necessário para cada atributo usado colocar como prefixo o
nome da tabela a qual pertence, por exemplo:
(1) Pacientes.nome, Pacientes.sexo
(2) Medicos.nome, medicos.crm
[ 73 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
(3) Doencas.iddoencas,doencas.descricao
(4) Consultas.dia, consultas.idmedico
(5) Dentre outros.
Vale ressaltar que o MySQL permite juntar até 16 tabelas numa
mesma instrução. Vamos proceder com exemplos crescentes
com duas ou várias tabelas.
Exemplo 1: Mostrar o nome dos pacientes e dia e hora de suas
consultas.
Para resolver essa questão vamos para cada passo. Os atributos
e tabelas envolvidos são: pacientes.nome, consultas.dia,
consultas.hora. Ressaltamos que as tabelas envolvidas são
CONSULTAS e PACIENTES. 
A primeira parte dessa consulta seria:
select pacientes.nome, consultas.dia, consultas.hora from
pacientes
Observem que a cláusula FROM TABELA é mantida, e
estabelecemos PACIENTES como a tabela1. Portanto a tabela2
da consulta será a tabela CONSULTAS.
O passo dois é aplicar a junção [INNER, LEFT, RIGHT] para
realizar a junção. No nosso caso será o INNER JOIN. Como dito
no passo 2 usando as chaves do relacionamento e as regras de
junção Tabela1.Chave1 = tabela2.chave1. Sendo assim nossa
consulta ampliada ficaria assim:
[ 74 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
select pacientes.nome, consultas.dia, consultas.hora from
pacientes INNER JOIN consultas ON pacientes.idpacientes
=consultas.idpacientes;
Observe que a junção é sempre formada nos seguintes
detalhes:
pacientes INNER JOIN consultas ON
E finalmente na associação das chaves primárias e estrangeiras
das tabelas envolvidas: 
PACIENTES.idpacientes = CONSULTAS.idpacientes
Observe que a associação (ou relacionamento) das duas tabelas
é feito através da chave idpacientes Vale destacar que o sinal
de igualdade (=) determina que tabelas estão à esquerda (LEFT)
ou a direita (RIGHT) da igualdade, sendo determinantes nos
casos de uso, para utilização do LEFT JOIN ou RIGHT JOIN.
Voltando a nossa questão do exemplo 1, temos a seguinte
resposta para a questão:
[ 75 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
Figura 56 – Junção de tabelas com INNER JOIN
Observem que os passos 3,4 e 5 não são usados uma vez que 
não tivemos filtros (WHERE), agrupamentos (GROUP BY), ou 
ordenações (ORDER BY), passos que são opcionais e depende 
de cada questão problema. Para ilustrar essa situação vamos 
ampliar a questão anterior.
Exemplo 2: Mostrar o nome dos pacientes e dia e hora de suas
consultas, desde que tenham acontecido pela manhã,
ordenadas por nome do paciente.
Agora para responder essa questão basta executarmos o passo
3 e 5, já que não precisamos por enquanto de agrupamento.
Vale lembrar que agora os atributos devem ser representados
sempre associados com sua tabela de origem como prefixo. Por
exemplo consultas.hora e pacientes.nome. Tendo em vista
essas observações importantes, que evitam problemas e erros,
a resposta para o questionamento do exemplo 2 seria dada a
seguir:
[ 76 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
Figura 57 – Junção de tabelas com cláusula where e order by
Até agora não combinamos ainda o uso de agrupamento em 
junções, para isso vamos fornecer um exemplo novo.
Exemplo 3: Mostrar o nome e crm do médico, bem como o
total de consultas que ele realizou.
Nessa junção de tabelas haverá um agrupamento para a
contagem de consultas para médicos (usando a função
COUNT). As tabelas envolvidas são MEDICOS e CONSULTAS.
Sempre prefiro estabelecer como tabela do FROM a tabela que
tem a chave primária (MEDICOS). Vamos ao primeiro resultado:
Figura 58 – Junção de tabelas com função de agregação
[ 77 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
Esse resultado acima pareceu um pouco estranho. Parece que
temos apenas um médico que concentrou todas as consultas. O
que deu errado? Justamente, esquecemos de realizar o
agrupamento (objetivo do exemplo). Para corrigirmos isto,
vamos agrupar pelo atributo idmedicos. Com a devida
correção, a resposta correta para o exemplo 3 é a seguinte:
Figura 59 – Consulta corrigida com o agrupamento pelo idmedicos
Agora temos a resposta correta para a pergunta dada. Apenas
temos um porém. Os médicos cadastrados sem nenhuma
consulta realizada não aparecerão nesta listagem. Isto ocorre
pelo fato do INNER JOIN trazersempre uma interseção de
conjuntos. Para contornar isto vamos usar o LEFT JOIN. Para
isto vamos variar o exemplo anterior.
Exemplo 4: Mostrar o nome e crm do médico, bem como o
total de consultas que ele realizou, ordenadas pelo total de
consultas.
[ 78 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
Como comentamos, para trazermos todos os médicos, inclusive
aqueles sem consultas, precisamos priorizar a tabela médicos.
Isso é feito através do LEFT ou RIGHT JOIN que definem que
tabela terá todos os dados trazidos nos resultados, pra
somente depois realizar a junção. Já mencionamento que o
lado na igualdade nos critérios de junção Tabela1.Chave1 =
tabela2.chave1, determinam a tabela prioritária. Como quero
priorizar a tabela MEDICOS, que está a esquerda da igualdade
usaremos o LEFT JOIN. Sendo assim teríamos o seguinte
resultado:
Figura 60 – Consulta usando LEFT JOIN ordenada pelo total de consultas
Uma pergunta comum que os estudantes sempre fazem é: “o
que aconteceria se não houvesse consultas pra um médico?
Para ilustrar isto vamos fazer um exemplo simples.
Exemplo 5: Mostrar o nome e idmedicos dos médicos e caso
tenham consultas, dia e hora.
[ 79 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
Figura 61
– Consulta usando LEFT JOIN com valores nulos (NULL)
Observe que demos ênfase nos médicos Ana Smith e Marcus, 
que tem os valores NULL (nulo) para dia e hora de consulta e 
para o atributo consultas.idmedicos. Isso indica que eles não 
realizaram consultas.
Se fizéssemos o questionamento, perguntando quais os
médicos que não realizaram consultas, usando o conceito de
subconsultas apresentados anteriormente teríamos o seguinte:
[ 80 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
Figura 62 – Subconsultas buscando médicos sem consultas realizadas
Agora uma conclusão possível: O conjunto de dados de um
LEFT ou RIGHT JOIN é sempre maior ou igual ao conjunto de
dados do INNER JOIN. Isso Significa que o conjunto de dados de
um INNER JOIN está contido num LEFT ou INNER JOIN.
Apenas para ilustrar um exemplo usando RIGHT JOIN, vou
repetir a consulta do exemplo 5.
Figura 63 – Uso do RIGHT JOIN para o exemplo 5
Se você estiver fazendo esses exemplos no computador vai
perceber que o conjunto RIGHT JOIN e INNER JOIN são
[ 81 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
equivalentes. Isso ocorre pois ao priorizar a tabela consultas (à
direita), apenas vamos listar consultas realizadas, as quais não
existem sem médicos. Para ilustrar isto, vou apenas mostra o
nome dos médicos nos três casos (sem repetição). Vou aplicar
um limitador para 5 registros, com o comando LIMIT 5;
Figura
64 – Uso do RIGHT JOIN priorizando consultas (tabela da direita)
Figura 65 – Uso do INNER JOIN para consultas
[ 82 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
Observem que os resultados são idênticos para as consultas
realizadas tanto com INNER ou RIGHT JOIN, como já havíamos
explicado antes. Para ilustrar a diferença, mostramos a seguir a
versão LEFT JOIN, já discutida com o exemplo de subconsultas.
Observe que Ana Smith estava na lista de médicos sem
consulta realizada, como apresentado na figura 62.
Figura 66 – Uso do LEFT JOIN para consultas
Vamos agora juntar mais de 2 tabelas. Basta seguir os passos já
estabelecidos anteriormente.
Exemplo 6: Mostrar o nome do paciente e do médico, bem
como dia e hora das consultas realizadas.
Já havíamos realizado parte dessa consulta ao juntar a tabela
PACIENTES e CONSULTAS. Para dar resposta a este exemplo,
precisamos juntar a tabela MEDICOS.
[ 83 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
Figura 67 – Junção de 3 tabelas com INNER JOIN
Observe no destaque da figura 67, que a junção adicional para
a tabela médicos é realizada através do comando inner join
medicos on consultas.idmedicos = medicos.idmedicos.
Sendo assim caso quiséssemos saber qual a especialidade do
médico, bastaria uma nova junção. Ou até mesmo o nome da
doença atendida, etc. Vale destacar que na exibição dos dados
aparece a coluna nome duas vezes. Vamos usar um rótulo (alias
ou apelido) para tais colunas. Veja a seguir:
Figura 68 – Uso de Alias ou rótulo para as colunas NOME
[ 84 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
Exemplo 6: Mostrar o nome do paciente e do médico, bem
como dia e hora das consultas realizadas. Mostre também a
especialidade médica.
Figura 69 – Junção de 4 tabelas, exibindo a especialidade médica
Observe que foi adicionada a junção para a tabela
ESPECIALIDADES com o comando:
inner join especialidades 
on medicos.idespecialidades = especialidades.idespecialidades
Usando o mesmo princípio podemos juntar quantas tabelas
forem necessárias para responder a um questionamento a
nossa base de dados.
Diante do que aprendemos sobre junções de tabelas vamos
responder mais quatro questões de exemplo que possa
misturar boa parte dos conceitos ora aqui apresentados.
(Questão 1) Mostre os médicos com idade acima de 30 anos
que atenderam gripe 
[ 85 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
Para resolver essa questão, precisamos ter em mente que
vamos exibir dados de médico e o nome de doença atendida,
que neste caso será gripe (filtro), desde que o médico tenha
mais de 30 anos (filtro). Apesar de exibirmos dados de apenas
duas tabelas, é necessariamente´obrigatório passar pela tabela
CONSULTAS, é por meio dela que se associam os dados de
doença e médico. Logo teremos três tabelas envolvidas
(MEDICOS, CONSULTAS, DOENCAS).
Vamos solucionar em duas fases essa questão: 
a) Junção das tabelas
Figura 70 – Junção de tabelas sem filtros (WHERE)
b) Aplicação de filtros de idade >30 e doenca = gripe
[ 86 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
Figura 71 – Consulta completa com os filtros de doença e idade
(Questão 2) - Mostre a média salarial dos médicos por
especialidade, cuja idade seja maior que 30.
Para resolver essa questão vamos envolver agrupamento por
especialidade médica, o cálculo da media salarial pela função
AVG() e um filtro (WHERE) pra a idade.
Figura 72 – Resposta para a questão 2
(Questão 3) - Mostre o nome das doenças que comecem com
a letra G, e para aquelas que têm consultas, exiba os dias de
consultas ordenados.
Para resolver essa questão precisamos considerar que até
agora não trabalhamos com busca textual parcial. Para isso
vamos precisar apresentar o operador LIKE (em português
“parecido”). Além disso, é possível que algumas doenças
cadastradas podem ainda não ter consultas realizadas para sua
descrição. Sendo assim, usar INNER JOIN é inadequado. Só
usamos INNER JOIN (considerando que é uma interseção de
conjuntos) somente se sabemos que há consulta para aquela
doença. Vamos assim optar pelo uso do LEFT JOIN.
[ 87 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
Vamos agora apresentar na forma de tabela alguns exemplos
de LIKE e do operador %:
Exemplo Significado
Nome LIKE ‘A%’ Atributo Nome comece com a letra A
Nome LIKE ‘%A’ Atributo Nome termine com a letra A
Nome LIKE ‘%PA%’ Atributo Nome o conjunto de caracteres PA
Para exemplificar o uso do LIKE, vamos pra uma consulta
simples. Exibir os nomes de médicos que começam com M.
Figura 73-Exemplo de uso do operador Like
Uma vez exemplificado o uso do operador LIKE, retomamos a
nossa questão. Lembrando que vamos usar o LEFT JOIN como
forma de junção de tabelas. É bom deixar claro que embora em
alguns exemplos, junções com RIGHT e LEFT JOIN possam
retornar valores NULL, isto não é uma regra.
Sendo assim, a resposta para a questão é dada a seguir:
[ 88 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa LeiteJúnior
Figura 74– Resultado da junção usando LEFT JOIN e operador LIKE
(Questão 4) Mostre um ranking com as doenças com maior
número de atendimentos. 
Para resolver essa questão vamos aproveitar a junção da
questão anterior, lembrando que temos agora que contar
atendimentos em consultas por doença, lembrando da
possibilidade de algumas doenças sequer ter tido atendimentos
(evitamos o INNER JOIN). Além disso, como ranking precisamos
de ordenação, de modo geral, na ordem decrescente pelo total
de atendimentos. Não custa relembrar que contagem (COUNT)
é uma função de agregação, de modo que será exigido
agrupamento pelo nome (descrição) da doença. Essa é a forma
de agrupamento mais comum, mas sempre prefiro agrupar
pela chave primária, neste caso iddoencas. Já usamos
anteriormente o comando LIMIT 5, que limita o resultado da
consulta a 5 registros. Podemos especificar com esse comando
[ 89 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
N registros a serem exibidos. Deste modo o resultado para a
questão dada se encontra na figura75.
Figura 75 – Ranking de atendimento por doenças com um limite de 5.
Exercícios para resolução
1) Mostre as especialidades e para aquelas que tem médico mostre
o nome dos médicos.
2) Mostre o nome do paciente e para aqueles que têm consultas
realizadas, mostre as datas em ordem decrescente.
3) Mostre os dados dos médicos e consultas realizadas, mostre o dia e
a hora da consulta.
4) Mostre o nome das doenças que comece com a letra A, e para
aquelas que têm consultas ordenados as por data.
5) Mostre o total de funcionários do sexo masculino e para aqueles
que possuem salário maior que 2 mil, mostre seu ambulatório.
6) Mostre as doenças que não possuem consultas agendadas
7) Mostre o nome dos pacientes e suas respectivas consultas, e para
aquelas que foram realizadas no turno da tarde, mostre o sexo do
paciente.
8) Mostre o nome do médico, o número do ambulatório e o dia e hora
de uma consulta.
9) Mostre o número do ambulatório que não possuem consultas
realizadas.
[ 90 ]
 Aprendendo Banco de Dados com MySQL, por Jorge Costa Leite Júnior
10) Mostre as consultas realizadas e para aquelas realizadas no turno
da manhã, o nome do médico para médicos que ganham mais de
3mil reais.
11) Mostre o nome do médico e para aqueles que possuem consultas
no período da tarde a data da consulta.
12) Mostre o nome e o crm do médico e o ambulatório que ele
pertence, que não realizou atendimento em consultas.
13) Mostre todos os ambulatórios e, para aqueles ambulatórios onde
médicos realizam atendimento, exibir também os seus códigos e
nomes.
14) Mostre todas as doenças e para aquelas possuem consultas
realizadas, exibir o nome dos pacientes do sexo masculino.
15) Mostre todos os médicos, para aqueles médicos com consultas
marcadas, exibir os crm e nomes dos seus pacientes e as datas das
consultas.
[ 91 ]
	Introdução
	Bancos de dados
	Um pouco sobre o uso do MySQL.
	Explorando um banco de dados real
	Como Modificar dados de um banco?
	Criando nossos próprios bancos e tabelas
	Ampliando nossos conhecimentos sobre o Select, Delete, Insert e Update
	Junções de tabelas