Académique Documents
Professionnel Documents
Culture Documents
Para exemplificar esse tipo de operação vamos criar duas tabelas com
um campo comum
1
Tabela cliente
2
Tabela conta
3
Relacionamento de tabelas
4
Relacionamento de tabelas
Arquivo BD1-A12-cliente.txt
111,Dedeh,Andrade Neves,Pelotas,RS,90000-000
221,Angelo,Bento,Pelotas,RS,91000-000
331,Roberto,Bento,Pelotas,RS,91000-000
213,Carlinhos,Amarante,Campinas,SP,20000-000
444,Gladislau,Donja,Pelotas,RS,93000-000
555,Pablo Escobar,Laranjal,Pelotas,RS,90000-000
664,Tio da Sukita,Pampas,Herval,RS,70000-000
5
Relacionamento de tabelas
Arquivo BD1-A12-conta.txt
A12345,1284.47,2018-10-21,221
A12346,2284.00,2018-10-22,111
A12347,3284.50,2018-09-23,331
B12348,4284.47,2019-10-24,331
B22349,5284.29,2018-09-10,331
B32341,6284.47,2018-10-11,221
C42340,233.22,2019-09-10,331
C52342,284.47,2018-10-11,555
Y17133,14.71,2018-10-23,555
Z17144,0.02,2018-09-24,221 6
Importando dados de um TXT para uma
tabela
7
Relacionamento de tabelas
8
Relacionamento de tabelas
10
Informações Agrupadas
Obter a quantidade de contas existente de cada cliente.
Para solucionar esta necessidade, deve-se utilizar junto a WHERE a
cláusula GROUP BY
11
Informações Agrupadas
Para exibir o nome do cliente e não o código:
12
Informações Agrupadas
Exemplo:
SELECT codcli, AVG(valor)
FROM conta
GROUP BY codcli;
Observe que quando usamos GROUP BY a função AVG() retorna a média calculada
para cada componente do grupo especificado, no caso "codcli".
13
Informações Agrupadas
Podemos também testar o valor retornado por avg():
Por exemplo: Exibir os clientes que possuem a média dos valores das
contas maior que 2000
SELECT codcli, AVG(valor)
FROM conta
GROUP BY codcli
HAVING AVG(valor)>2000;
Note que a cláusula having usada aqui tem o mesmo significado que where nas
consultas normais.
OBS: a cláusula “WHERE” não pode ser usada para restringir grupos que deverão ser
exibidos. Acompanhando o GROUP BY utilizamos a cláusula “HAVING”.
14
Rollup
Quando se utiliza a cláusula GROUP BY, como por exemplo, totalizar as
contas por cliente, o gerenciador retorna a consulta com uma linha para
cada cliente. O modificador ROLLUP faz com que o MySQL retorne
também as linhas totalizadas, ou seja, o total por cliente e o total geral.
Exemplo:
SELECT codcli, COUNT(valor), SUM(valor),
AVG(valor)
FROM conta
GROUP BY codcli
WITH ROLLUP;
15
Rollup
SELECT codcli, SUM(valor)
FROM conta
GROUP BY codcli;
SELECT codcli,SUM(valor)
FROM conta
GROUP BY codcli
WITH ROLLUP;
16
Rollup
18
Definição de Apelidos
• SQL permite dar um nome diferente de uma tabela, campo ou fórmula do nome real
existente.
• Isso é conseguido com o comando AS utilizado junto com o SELECT
• Quando pedimos para exibir o nome e a quantidade de contas existentes para cada
cliente, foram apresentadas as colunas nome e COUNT. Para que a coluna COUNT seja
chamada de contas usamos a seguinte sintaxe:
19
DISTINCT
Queremos saber quais as cidades dos nossos clientes, mas como
podemos ter vários clientes da mesma cidade, usamos o DISTINCT para
não mostrar várias vezes o mesmo nome de cidade.
20
Exercícios
1. Apresentar uma listagem identificada pelos apelidos Cliente (para
representar o campo nome) e Vencidos (para representar o número de
contas vencidas existente na tabela conta que será calculada pela função
COUNT) de todos os clientes que possuem contas com vencimento
anterior a 31/12/2018.
21
Subquery
Elas podem ser muito úteis quando for necessário selecionar linha a partir de uma
tabela com uma condição que dependa de dados da própria tabela.
22
Subquery
23
Regras Gerais
A subquery deve ser colocada entre parênteses, deve ser colocada
depois de um operador de comparação, cláusula ORDER BY não deve ser
incluída em uma subquery.
Exemplo:
SELECT nome
FROM cliente
WHERE cidade = (SELECT cidade FROM cliente WHERE
nome=‘Gladislau’);
Obs.: Primeiro descobrirá a cidade de Gladislau, depois exibirá o nome
dos clientes da mesma cidade que Gladislau. 24
Exemplos
25
Utilizando JOINS
Utilizar a cláusula WHERE para fazer seus JOINs (relacionamentos), limita os
relacionamentos a apenas um tipo deles, o INNER JOIN.
26
INNER JOIN
Retorna apenas as linhas das tabelas que sejam comuns entre si, ou seja, as linhas
em ambas as tabelas que possuam o campo de relacionamento com o mesmo
valor.
27
LEFT JOIN
Irá listar todas as linhas da primeira tabela relacionada no JOIN, logo após a
cláusula FROM.
28
RIGHT JOIN
Neste caso também , quando a linha listada não possuir equivalência na tabela
destino , as colunas da tabela destino aparecerão com valores nulos
29
Comandos SQL – DML - JOIN
A B
30
Comandos SQL – DML - JOIN
A B
id valor id valor
---- ---------- ---- ----------
1 FOX 1 TROT
2 COP 2 CAR
3 TAXI 3 CAB
6 WASHINGTON 6 MONUMENT
7 DELL 7 PC
5 ARIZONA 8 MICROSOFT
4 LINCOLN 9 APPLE
10 LUCENT 11 SCOTCH
31
Comandos SQL – DML - JOIN
INNER JOIN
Retorna todos os registros na tabela à esquerda (tabela A) que
tem um registro correspondente na tabela direita (tabela B).
32
Comandos SQL – DML - JOIN
INNER JOIN
SELECT *
FROM A INNER JOIN B ON (A.id = B.id);
SELECT *
FROM A , B WHERE (A.id = B.id);
33
Comandos SQL – DML - JOIN
INNER JOIN
+------+------------+----------+------+
| a.id | a.valor | b.valor | b.id |
+------+------------+----------+------+
| 1 | FOX | TROT | 1 |
| 2 | COP | CAR | 2 |
| 3 | TAXI | CAB | 3 |
| 6 | WASHINGTON | MONUMENT | 6 |
| 7 | DELL | PC | 7 |
+------+------------+----------+------+
34
Comandos SQL – DML - JOIN
LEFT JOIN
Retorna todos os registros na tabela esquerda (tabela A),
independentemente se algum desses registros têm uma
correspondência na tabela direita (tabela B).
Também retornará os registros correspondentes na tabela
direita.
35
Comandos SQL – DML - JOIN
LEFT JOIN
SELECT *
FROM A LEFT JOIN B ON (A.id = B.id);
36
Comandos SQL – DML - JOIN
LEFT JOIN
+------+------------+----------+------+
| a.id | a.valor | b.valor | b.id |
+------+------------+----------+------+
| 1 | FOX | TROT | 1 |
| 2 | COP | CAR | 2 |
| 3 | TAXI | CAB | 3 |
| 6 | WASHINGTON | MONUMENT | 6 |
| 7 | DELL | PC | 7 |
| 5 | ARIZONA | NULL | NULL |
| 4 | LINCOLN | NULL | NULL |
| 10 | LUCENT | NULL | NULL |
+------+------------+----------+------+
37
Comandos SQL – DML - JOIN
RIGHT JOIN
Retorna todos os registros na tabela direita (tabela B),
independentemente se algum desses registros têm uma
correspondência na tabela da esquerda (tabela A).
Também retornará os registros correspondentes da tabela à
esquerda.
38
Comandos SQL – DML - JOIN
RIGHT JOIN
SELECT *
FROM A RIGHT JOIN B ON (A.id = B.id);
39
Comandos SQL – DML - JOIN
RIGHT JOIN
+------+------------+-----------+------+
| a.id | a.valor | b.valor | b.id |
+------+------------+-----------+------+
| 1 | FOX | TROT | 1 |
| 2 | COP | CAR | 2 |
| 3 | TAXI | CAB | 3 |
| 6 | WASHINGTON | MONUMENT | 6 |
| 7 | DELL | PC | 7 |
| NULL | NULL | MICROSOFT | 8 |
| NULL | NULL | APPLE | 9 |
| NULL | NULL | SCOTCH | 11 |
+------+------------+-----------+------+
40
Comandos SQL – DML - JOIN
OUTER JOIN
Este JOIN também pode ser chamado de FULL OUTER JOIN
ou FULL JOIN.
Retorna todos os registros de ambas as tabelas, juntando-se os
registros da tabela da esquerda (tabela A) que os registros
correspondentes na tabela da direita (tabela B).
41
Comandos SQL – DML - JOIN
OUTER JOIN
Obs.: O MySQL não possui o comando OUTER JOIN.
42
Comandos SQL – DML - JOIN
OUTER JOIN
Exemplo em SQL
SELECT *
FROM A FULL OUTER JOIN B (ON A.id = B.id);
43
Comandos SQL – DML - JOIN
OUTER JOIN
Exemplo (compatível) em MySQL
SELECT *
FROM A LEFT JOIN B ON (A.id = B.id)
UNION
SELECT *
FROM A RIGHT JOIN B ON (A.id = B.id);
44
Comandos SQL – DML - JOIN
OUTER JOIN
+------+------------+-----------+------+
| a.id | a.valor | b.valor | b.id |
+------+------------+-----------+------+
| 1 | FOX | TROT | 1 |
| 2 | COP | CAR | 2 |
| 3 | TAXI | CAB | 3 |
| 6 | WASHINGTON | MONUMENT | 6 |
| 7 | DELL | PC | 7 |
| 5 | ARIZONA | NULL | NULL |
| 4 | LINCOLN | NULL | NULL |
| 10 | LUCENT | NULL | NULL |
| NULL | NULL | MICROSOFT | 8 |
| NULL | NULL | APPLE | 9 |
| NULL | NULL | SCOTCH | 11 | 45
Comandos SQL – DML - JOIN
46
Comandos SQL – DML - JOIN
SELECT *
FROM A LEFT JOIN B ON (A.id = B.id)
WHERE (B.id IS NULL);
47
Comandos SQL – DML - JOIN
48
Comandos SQL – DML - JOIN
49
Comandos SQL – DML - JOIN
SELECT *
FROM A RIGHT JOIN B ON (A.id = B.id)
WHERE (A.id IS NULL);
50
Comandos SQL – DML - JOIN
51
Comandos SQL – DML - JOIN
52
Comandos SQL – DML - JOIN
53
Comandos SQL – DML - JOIN
54
Comandos SQL – DML - JOIN
55
Comandos SQL – DML - JOIN
Fonte: http://www.codeproject.com
56
Crie as tabelas conforme solicitado
CLI
CLI Codigo Nome
Codigo - INTEIRO - AUTO NUMERAÇÃO – CHAVE 1 José
Nome – CHAR (30) 2 Elisio
3 Roberto
4 Guilherme
PEDIDO
nr Cliente valor
1 2 100.50
PEDIDO 2 2 120.00
nr - INTEIRO – CHAVE 3 1 20.00
cliente – INTEIRO 4 3 60.00
valor – FLOAT(5,2) 5 3 110.00 57
INNER JOIN
SELECT pedido.nr, cli.nome, pedido.valor
FROM cli
INNER JOIN pedido ON (cli.codigo = pedido.cliente);
58
Observe que o cliente Guilherme não fez nenhum pedido.
E se você quiser um relatório que mostre também os clientes
que não fizeram nenhum pedido?
Você terá que usar uma junção chamada LEFT JOIN:
60
Lance mais alguns Clientes na tabela Cli mas não lance Pedidos para eles.
61
Abaixo vemos exemplos do uso de COUNT():
SELECT COUNT(valor)
FROM cli
LEFT JOIN pedido ON (cli.codigo = pedido.cliente);
SELECT COUNT(*)
FROM cli
LEFT JOIN pedido ON (cli.codigo = pedido.cliente);
62
Alias para Tabelas
• Quando usamos JOIN, o nome da tabela é citado para diferenciar a qual campo se
está fazendo referência. Quando a consulta é complexa e envolve várias tabelas,
referenciar o nome da tabela pode aumentar muito o tamanho da consulta e em
algumas ferramentas como Delphi, há um limite de 255 caracteres para a consulta.
• Para criar um alias para uma tabela, basta acrescentar um identificador à frente do
nome da tabela. A partir de então, basta utilizar este alias para se referenciar à
tabela.
63
Exercícios
65
Exercícios
3 - Listar o renavam, modelo, marca, cor e nome do proprietário de todos os carros.
66
Exercícios
1 - Exiba quantos carros tem cada proprietário.
67
Exercícios
1 - Exiba quantos carros tem cada proprietário.
SELECT p.nome AS Proprietário, COUNT(c.renavam) AS qtd_veículos
FROM proprietarios p
LEFT JOIN carros c ON p.rg = c.rg
GROUP BY p.nome;
70
Execute o comando:
Exercício:
1. Exibir a quantidade e o valor total dos pedidos por
cliente:
71
Execute o comando:
Exercício:
1. Exibir a quantidade e o valor total dos pedidos por
cliente:
SELECT c.nome AS Cliente, COUNT(p.valor) AS Quantidade, SUM(p.valor) AS Total
FROM cli c
LEFT JOIN pedido p ON c.codigo = p.cliente
GROUP BY c.nome
ORDER BY c.nome;
72
Verifique a tabela empregados criada anteriormente, como
mostra a figura abaixo:
1. Faça uma consulta para verificar a média de salários de cada setor, porém
apresente resposta apenas para setores com mais de 2 empregados.
2. Faça uma consulta para verificar a média de salários de cada setor, porém
apresente resposta apenas para setores com média maior que R$1600,00.
OBS: a cláusula “WHERE” não pode ser usada para restringir grupos que deverão
ser exibidos. Acompanhando o GROUP BY utilizamos a cláusula “HAVING”.
74
Exercícios com Subquery
1. Exiba o nome de todos os empregados que trabalham no mesmo
setor da Aline Brito
75
Para o exercício de cliente e conta :
1. Exiba o cliente que possui a menor conta
4. Exiba a cidade dos cliente que possuem conta acima do valor médio
das contas
76
Exercícios
Criar três tabelas no banco de dados: funcionarios, pagamentos e
descontos.
CREATE TABLE funcionarios( funcionarios
codigo_funcionario INT, 1 Luis
nome VARCHAR(50) ); 2 Marina pagamentos
3 Letícia 1 1 100
CREATE TABLE pagamentos( 4 Gustavo 2 1 200
codigo_pagto INT, 5 Mateus 3 3 300
codigo_funcionario INT, 4 5 400
valor DECIMAL(10,2) ); 5 5 500
descontos
CREATE TABLE descontos( 1 1 50
codigo_desconto INT, 2 2 20
codigo_funcionario INT, 3 5 30
valor DECIMAL(10,2) ); 77
Exemplo de INNER JOIN
Apesar de termos cinco funcionários na tabela, ele mostrou apenas três, o motivo
é que apenas estes três tem pagamentos. Veja que o INNER JOIN fez uma junção
entre funcionarios e pagamentos e desconsiderou os funcionários sem
pagamentos.
78
INNER JOIN com três tabelas
Neste caso apenas dois funcionários foram mostrados já que incluímos na consulta os
descontos, ou seja, a leitura que esta consulta fez é: mostrar funcionários que tem
pagamentos e descontos.
79
Exemplo de LEFT JOIN
81
Fazendo “perguntas” ao
MySQL
SELECT VERSION(); ->5.6.26
SELECT CURRENT_DATE; ->2018-10-23
SELECT USER(); ->root@localhost
SELECT NOW(); ->2018-10-231 23:13:22
SELECT CONCAT_WS(“-",“Faculdade",“SENAC",“Pelotas");
-> Faculdade-SENAC-Pelotas
SELECT CHAR_LENGTH(“FATEC”);
-> 5
85
MySQL – Função SUBSTRING()
Extrai um número específico de caracteres a partir de uma posição
86
MySQL – Função SUBSTRING()
87
MySQL – Função SUBSTRING()
88
MySQL – Função SUBSTRING()
89
Funções String
SUBSTRING_INDEX(str, delim, count)
SELECT SUBSTRING_INDEX('www.mysql.com', '.', 2);
-> 'www.mysql'
SELECT UCASE(‘Paulo');
-> ‘PAULO’
SELECT UPPER(‘Paulo');
-> ‘PAULO’
SELECT LCASE('MYSQL');
-> 'mysql‘
SELECT LOWER('MYSQL');
-> 'mysql'
91
Funções Data
SELECT DAYOFWEEK (“2018-10-31”);
-> 2 OBS:(1 = Domingo, 2 = Segunda, ... 7 = Sábado)
SELECT WEEKDAY(“2018-10-31“);
-> 0 OBS:(0 = Segunda, 1 = Terça, ... 6 = Domingo)
SELECT MONTHNAME(“2018-10-31”);
-> ‘October'
93
Indexação de Tabelas
• Índices permitem encontrar registros com um valor específico de um
campo mais rapido.
94
Indexação de Tabelas
• Índice é um recurso que facilita a localização de informações dentro de uma
tabela, além de possibilitar a exibição ordenada de informações.
• A indexação precisa ser usada com cuidado pois causa lentidão, principalmente
nas operações de atualização de dados (update).
• Chave primária não devem ser indexados pois o fato de ser chave primária já cria
indiretamente uma indexação.
95
Indexação de Tabelas
A indexação é útil quando:
• Um determinado campo não deve conter valores duplicados, além do campo definido
como chave primária. Para o campo que for chave única deve ser criado um índice e
utiliza-se a cláusula opcional UNIQUE.
• Exemplo: Imagine além do campo código do cliente (que está definido como chave
primária) o campo CNPJ não pode conter valores duplicados. Neste caso, para o
campo CNPJ, cria-se um índice.
• Quando consultas são realizadas com grande frequência sobre um campo que não é
definido como chave primária.
• Exemplo: Pode-se consultar cliente pelo código ou pelo CNPJ.
96
Indexação de Tabelas
• A seguir será criado um índice de nomes para a tabela Funcionarios,
usando como chave de indexação o campo nome. A indexação criada
está recebendo o nome nomeind.
97
Indexação de Tabelas
Um índice criado pode ser removido com o comando:
DROP INDEX <indice> ON <tabela>
98
Chave Estrangeira
• A restrição de chave estrangeira especifica que o valor da coluna (ou grupo
de colunas) deve corresponder a algum valor que existe em uma linha de
outra tabela.
99
Exemplo
• CREATE TABLE aluno (
ra INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
nome CHAR(30) NOT NULL
) ENGINE=InnoDB;
CREATE TABLE cursos (
id INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
nome CHAR(30) NOT NULL
) ENGINE=InnoDB;
100
Exemplo
CREATE TABLE notas (
ra INT NOT NULL,
curso_id INT NOT NULL,
date DATE NOT NULL,
nota DOUBLE NOT NULL,
PRIMARY KEY(ra, curso_id, date),
INDEX i2 (curso_id),
FOREIGN KEY (ra) REFERENCES aluno(ra) ON DELETE CASCADE,
FOREIGN KEY (curso_id) REFERENCES cursos(id) ON DELETE
RESTRICT
) ENGINE=InnoDB;
101
Integridade
• A tabela notas define duas restrições de chave estrangeira, fazendo
referência à tabela aluno e à tabela cursos.
102
Integridade
O InnoDB implementa as seguintes restrições de integridade:
• SET NULL e SET DEFAULT (atribuem os valores DEFAULT ou NULL para as chaves
estrangeiras cujos registros relacionados foram excluídos) 103
Integridade
• No exemplo é possível que um curso possua várias avaliações em datas distintas. Neste
caso, foram criadas as tabelas como tipo InnoDB (TYPE=InnoDB), para que as regras de
integridade sejam respeitadas.
• As regras definidas foram: um CASCADE para aluno, isto é, se for removido um registro
da tabela de aluno, todas as suas notas serão removidas automaticamente.
• No caso da tabela de cursos, não será possível remover um curso que possua notas
cadastradas para ele.
104
Integridade
Além da restrição ON DELETE, o InnoDB permite também o ON UPDATE, que aplica
as restrições no caso de atualizações dos campos relacionados entre as tabelas.
105
Integridade
• É importante ressaltar que o FOREIGN KEY não cria automaticamente um índice na(s)
coluna(s) referenciada(s). É necessário criar explicitamente um índice nas colunas que
serão chaves estrangeiras.
• Como curso_id não é o primeiro campo de nenhuma chave, foi adicionado o índice
i2 para esta chave estrangeira.
• Caso não seja criado o índice nas chaves estrangeiras, o MySQL exibirá o erro "ERROR
1005: Can't create table 'notas.frm' (errno: 150)“. Significa
que há uma definição incorreta das chaves estrangeiras.
106