BANCO DE DADOS

Prévia do material em texto

· Pergunta 1
1 em 1 pontos
	
	
	
	Considere as seguintes tabelas:
CREATE TABLE paciente (id int primary key, nome text);
CREATE TABLE medico (id int primary key, nome text);
CREATE TABLE consulta (data date, id_paciente int, id_medico int);
Assinale a alternativa que indica uma consulta válida para identificarmos os médicos que não possuem consulta marcada na data de hoje.
	
	
	
	
		Resposta Selecionada:
	a. 
SELECT DISTINCT m.nome as nome_medico FROM medico m LEFT JOIN consulta c ON c.id_medico = m.id WHERE data != curdate() or data is null;
	Respostas:
	a. 
SELECT DISTINCT m.nome as nome_medico FROM medico m LEFT JOIN consulta c ON c.id_medico = m.id WHERE data != curdate() or data is null;
	
	b. 
SELECT DISTINCT m.nome as nome_medico FROM medico m JOIN consulta c ON c.id_medico = m.id WHERE data != curdate() or data is null;
	
	c. 
SELECT DISTINCT m.nome as nome_medico FROM medico m RIGHT JOIN consulta c ON c.id_medico = m.id WHERE data != curdate() or data is null;
	
	d. 
SELECT DISTINCT m.nome as nome_medico FROM medico m LEFT JOIN consulta c WHERE c.id_medico = m.id and data != curdate() or data is null;
	
	e. 
Dada a modelagem apresentada, não é possível realizar a consulta desejada com um único SELECT.
	Comentário da resposta:
	a. Com um LEFT JOIN, teremos os médicos associados a alguma consulta e também os médicos sem consultas. Para que a consulta devolva os médicos sem consulta alguma marcada, temos o “data is null”. Para que a consulta devolva os médicos com consulta marcada em outros dias que não o dia corrente, temos o “data != curdate()”. Sem o DISTINCT, a consulta SQL devolveria uma linha por consulta médica, o que poderia repetir os nomes dos médicos. Como queremos listar somente os médicos, o DISTINCT é desejável.
	
	
	
· Pergunta 2
1 em 1 pontos
	
	
	
	Considere uma tabela que registre as doações recebidas pelos partidos políticos para as eleições de 2014 no estado de São Paulo (Fonte: http://dados.gov.br/dataset/prestacao-de-contas-das-campanhas-eleitorais).
 
Considere que a tabela doacoes possui um schema conforme o seguinte comando:
 
CREATE TABLE doacoes (
 UF,
 SiglaPartido,
 DataReceita,
 Valor REAL,
 TipoReceita,
 FonteRecurso,
 EspecieRecurso,
 DescricaoReceita,
 DocumentoDoador,
 NomeDoador );
 
Considere agora a seguinte consulta SQL:
 
SELECT SiglaPartido, sum(Valor) as total_recebido FROM doacoes GROUP BY SiglaPartido ORDER BY total_recebido DESC LIMIT 5;
 
Assinale a alternativa que indica qual saída o comando acima pode produzir.
	
	
	
	
		Resposta Selecionada:
	e. 
SiglaPartido  total_recebido
------------  --------------
PSDB          57058765.03  
PT            37767199.76  
SD            18960025.0   
PSD           17706828.38  
PMDB          8748201.0  
	Respostas:
	a. 
… You have an error in your SQL syntax ...
	
	b. 
SiglaPartido  total_recebido
------------  --------------
PCO           91.66        
PCB           6950.0       
PRTB          7327.9       
PDT           10000.0      
PSC           18620.0
	
	c. 
SiglaPartido  Valor    
------------  ----------
PSDB          50000.0  
PSB           50000.0  
PT            700000.0 
PT            1615000.0
PT            500000.0 
	
	d. 
SiglaPartido  total_recebido
------------  --------------
PSDB          57058765.03  
	
	e. 
SiglaPartido  total_recebido
------------  --------------
PSDB          57058765.03  
PT            37767199.76  
SD            18960025.0   
PSD           17706828.38  
PMDB          8748201.0  
	Comentário da resposta:
	e. O “GROUP BY SiglaPartido” indica que cada partido deve aparecer somente uma vez na saída.  O LIMIT 5 indica que a saída deve ter apenas 5 registros. O “ORDER BY total_recebido DESC” indica que a coluna total_recebido deve estar em ordem decrescente.
	
	
	
· Pergunta 3
1 em 1 pontos
	
	
	
	Analise a seguinte sequência de comandos realizada com o usuário administrador (aquele que possui todos os privilégios sobre a instância do SGBD):
 
CREATE USER 'u1'@'%' IDENTIFIED BY 'senha';
CREATE USER 'u2'@'%' IDENTIFIED BY 'senha';
CREATE USER 'u3'@'%' IDENTIFIED BY 'senha';
 
CREATE DATABASE db1;
USE db1;
CREATE TABLE tb1 (id int, x int);
CREATE TABLE tb2 (id int, x int);
GRANT SELECT ON db1.* TO u1;
GRANT SELECT, DELETE ON db1.* TO u2;
GRANT UPDATE, INSERT ON db1.tb1 TO u3;
 
CREATE DATABASE db2;
USE db2;
CREATE TABLE tb1 (id int, x int);
CREATE ROLE r1;
GRANT ALL ON db2.* TO r1;
GRANT r1 TO u3;
SET DEFAULT ROLE ALL TO u3;
FLUSH PRIVILEGES;
 
Considerando que os comandos apresentados já foram executados (todos com sucesso), associe a lista de comandos à lista de trechos das saídas produzidas por esses comandos.
 
Lista de comandos (o sinal $ indica um comando realizado no sistema operacional e o sinal > indica um comando realizado no MySQL):
 
(I) $ mysql -u u1 db2 -psenha
 
(II) $mysql -u u2 db1 -psenha
> DROP tb2;
 
(III) $ mysql -u u3 db1 -psenha
> UPDATE tb1 SET x = 2*x WHERE x > 10;
 
(IV) $ mysql -u u3 db2 -psenha
> UPDATE tb1 SET x = 2*x WHERE x > 10;
 
Lista de trechos das saídas:
 
( ) SELECT command denied to user
 
( ) Access denied for user
 
( ) Query OK
 
( ) You have an error in your SQL syntax
 
A sequência correta dessa associação é:
	
	
	
	
		Resposta Selecionada:
	b. 
(III) (I) (IV) (II)
	Respostas:
	a. 
(IV) (I) (III) (II)
	
	b. 
(III) (I) (IV) (II)
	
	c. 
(IV) (I) (II) (III)
	
	d. 
(I) (II) (III) (IV)
	
	e. 
(IV) (III) (II) (I)
	Comentário da resposta:
	b. O comando I resultará em acesso negado, pois u1 não tem nenhum privilégio sobre db2. O comando II resultará em erro de sintaxe, pois o comando correto seria “DROP TABLE tb2”. O comando III resultará em erro de permissão, pois, apesar de ter direito ao UPDATE, u3 não possui direito de SELECT em db1.tb1, e a condição do WHERE impõe a necessidade de leitura da tabela. Já o comando IV resultará em sucesso, pois u3 recebeu os privilégios de r1, que tem acesso total a db2.
	
	
	
· Pergunta 4
1 em 1 pontos
	
	
	
	Considere a seguinte modelagem feita para o banco de dados de um sistema de estacionamento:
Descrição acessível: tabela estadia com campos inicio, fim e placa_veiculo; tabela veiculo com campos placa, marca, modelo, cor, cpf_dono e nome_dono; estadia.placa_veiculo é chave estrangeira para veiculo.placa.
Assinale a alternativa que indica em que forma normal se encontra essa modelagem.
	
	
	
	
		Resposta Selecionada:
	b. 
2FN.
	Respostas:
	a. 
1FN.
	
	b. 
2FN.
	
	c. 
3FN.
	
	d. 
BCFN.
	
	e. 
Essa modelagem não atende nem à 1FN.
	Comentário da resposta:
	b. Essa modelagem viola a 3FN, pois cpf_dono e nome_dono são funcionalmente dependentes entre si. Como há uma violação da 3FN e não há violações nem da 2FN nem da 1FN, então a modelagem apresentada está na 2FN. A modelagem não viola a 1FN pois não há campos multivalorados. Ela também não viola a 2FN, o que ocorreria se algum atributo não primário fosse funcionalmente dependente de parte de alguma chave da tabela.
	
	
	
· Pergunta 5
1 em 1 pontos
	
	
	
	Considere a seguinte tabela:
Tabela de municípios:
	nome
	uf
	populacao
	area
	São Paulo
	SP
	12 252 023
	1 521
	Belo Horizonte
	MG
	2 512 070
	331
	Sorocaba
	SP
	679 378
	450
	Guaratinguetá
	SP
	121 798
	752
	Rancharia
	SP
	29 707
	1 587
	Altamira
	PA
	114 594
	159 533
Fonte: https://cidades.ibge.gov.br/
É correto afirmar que essa tabela:
	
	
	
	
		Resposta Selecionada:
	c. 
Possui os campos “nome”, “uf”, “populacao” e “area”.
	Respostas:
	a. 
Possui 4 campos e 7 registros.
	
	b. 
Possui 4 registros.
	
	c. 
Possui os campos “nome”, “uf”, “populacao” e “area”.
	
	d. 
Utiliza todos os tipos de colunas presentes no MySQL: text e integer.
	
	e. 
Não é uma tabela; na verdade é uma tupla.
	Comentário da resposta:
	c. Cada coluna que vemos corresponde a um campo da tabela do banco de dados. A primeira linha que vemos representa os nomes dos campos; já as linhas subsequentes representam os registros da tabela do banco de dados.
	
	
	
· Pergunta 6
1 em 1 pontos
	
	
	
	Considere a seguinte tabela de pratos disponíveis em um restaurante:CREATE TABLE pratos (nome text, pais_origem text, vegetariano boolean, preco float); 
Considerando essa tabela, assinale a alternativa com o comando que torna possível a execução da seguinte consulta:
 
SELECT pais_origem as pais, count(*) as qtd_pratos_vegetarianos FROM pratos_vegetarianos GROUP BY pais_origem;
+--------+-------------------------+
| pais   | qtd_pratos_vegetarianos |
+--------+-------------------------+
| Índia |                      10 |
| Itália |                       7 |
| Brasil |                       4 |
+--------+-------------------------+
	
	
	
	
		Resposta Selecionada:
	b. 
CREATE VIEW pratos_vegetarianos AS SELECT nome, pais_origem FROM pratos WHERE vegetariano;
	Respostas:
	a. 
CREATE SUBSELECT pratos_vegetarianos AS SELECT nome, pais_origem AS pais FROM pratos WHERE vegetariano;
	
	b. 
CREATE VIEW pratos_vegetarianos AS SELECT nome, pais_origem FROM pratos WHERE vegetariano;
	
	c. 
CREATE SUBSELECT pratos_vegetarianos AS SELECT nome, pais_origem FROM pratos WHERE vegetariano;
	
	d. 
CREATE VIEW pratos_vegetarianos FROM SELECT nome, pais_origem FROM pratos WHERE vegetariano;
	
	e. 
CREATE VIEW FOR pratos AS SELECT * FROM pratos_vegetarianos WHERE vegetariano;
	Comentário da resposta:
	b. Para que a consulta funcione, é preciso criar uma view para a tabela pratos. E a sintaxe para criar uma view é CREATE VIEW <nome-da-view> AS <SELECT ...>.
	
	
	
· Pergunta 7
1 em 1 pontos
	
	
	
	Como o MySQL utiliza índices
 
Os índices são usados para rapidamente localizar linhas com valores de coluna específicos. Sem um índice, o MySQL deve começar com a primeira linha e depois ler a tabela inteira para encontrar as linhas relevantes. Quanto maior a tabela, mais isso custa. Se a tabela tiver um índice para as colunas em questão, o MySQL poderá determinar rapidamente a posição a ser procurada no meio do arquivo de dados sem precisar examinar todos os dados. Isso é muito mais rápido do que ler todas as linhas sequencialmente.
 
(Traduzido da documentação oficial do MySQL. Disponível em: <https://dev.mysql.com/doc/refman/8.0/en/mysql-indexes.html>. Acesso em: mar. 2020.
 
Sobre índices é correto afirmar que:
	
	
	
	
		Resposta Selecionada:
	d. 
Considere uma base de dados construída para análises científicas que é montada uma vez e depois não é mais atualizada, e que possui muitos dados. Nesse caso compensa construir diversos índices que serão úteis para as consultas dos cientistas, pois mesmo que o tempo de criação dos índices seja grande, a alta velocidade das leituras subsequentes compensará o tempo de criação dos índices.
	Respostas:
	a. 
A criação de índices é imprescindível para qualquer tabela do MySQL.
	
	b. 
Considere um sistema muito acessado por usuários de todo o mundo e uma tabela que armazene os eventos de login desses usuários. Nesse caso, a criação de um índice nessa tabela de registro de login é conveniente para acelerar o tempo de inserção, provendo uma melhor experiência para o usuário.
	
	c. 
Índices deixam inserções mais lentas e consomem mais espaço em disco. Por essas razões devem ser usados apenas em tabelas com mais de um milhão de registros. Só nesses casos os custos compensarão os ganhos de velocidade de leitura.
	
	d. 
Considere uma base de dados construída para análises científicas que é montada uma vez e depois não é mais atualizada, e que possui muitos dados. Nesse caso compensa construir diversos índices que serão úteis para as consultas dos cientistas, pois mesmo que o tempo de criação dos índices seja grande, a alta velocidade das leituras subsequentes compensará o tempo de criação dos índices.
	
	e. 
Os índices são recursos utilizados em bancos de dados antigos. O sistema de otimização de consultas do MySQL (optimum lookup process) dispensa a utilização de índices em tabelas do MySQL.
	Comentário da resposta:
	d. Índices aceleram consultas e são muito utilizados. Um problema muito comum em sistemas lentos é a falta de índices em tabelas do banco de dados (seja no MySQL ou em outros SGBDs). Por outro lado, o preço a se pagar é: inserções mais lentas e mais espaço ocupado no disco. Contudo, tabelas muito pequenas podem dispensar índices.
	
	
	
· Pergunta 8
1 em 1 pontos
	
	
	
	Considere a tabela municipio criada com o seguinte comando:
 
CREATE TABLE municipio (
    id int auto_increment primary key,
    nome text,
    uf varchar(2)
);
 
Considere ainda o seguinte estado para a essa tabela:
 
> select * from municipio;
+----+------------+------+
| id | nome       | uf   |
+----+------------+------+
|  1 | São Paulo  | SP   |
|  2 | Osasco     | SP   |
|  3 | Mateiros   | TO   |
+----+------------+------+
 
Dado o estado definido acima, considere a execução do seguinte comando:
 
INSERT INTO municipio (nome, uf) VALUES ('Salvador', 'BA');
 
Considere agora as seguintes afirmações:
 
I – A execução do comando acima incorrerá em erro.
II – A chave primária deve ser especificada no comando INSERT.
 
Assinale agora a opção correta.
	
	
	
	
		Resposta Selecionada:
	b. 
As sentenças I e II são falsas.
	Respostas:
	a. 
As sentenças I e II são verdadeiras e a II é a explicação da I.
	
	b. 
As sentenças I e II são falsas.
	
	c. 
A sentença I é verdadeira, mas a II é falsa.
	
	d. 
As sentenças I e II são verdadeiras, mas a II não é a explicação da I.
	
	e. 
Apenas a sentença II é verdadeira.
	Comentário da resposta:
	b. A chave primária foi especificada com a opção auto_increment, o que dispensa a especificação da chave primária no comando INSERT.
	
	
	
· Pergunta 9
1 em 1 pontos
	
	
	
	Considere a tabela abaixo, denominada tab1 e contendo as colunas col1 e col2.
	col1
	col2
	10
	1
	20
	2
	30
	3
Descrição acessível: Tabela com duas colunas: col1 e col2. Conteúdo composto apenas de números.
A SQL possui um recurso que possibilita a execução de operações aritméticas entre as colunas, como demonstra a seguinte consulta:
 
> SELECT col1 + col2 as soma FROM tab1;
soma
11
22
33
 
Considere ainda a existência de uma tabela acidentes_aereos, em que cada registro representa um acidente aéreo e que possui as colunas quantidade_passageiros e quantidade_vitimas_fatais.
 Assinale a alternativa que corretamente consulta a porcentagem de vítimas fatais (em relação ao total de passageiros) de cada acidente na tabela acidentes_aereos.
	
	
	
	
		Resposta Selecionada:
	e. 
SELECT quantidade_vitimas_fatais /
quantidade_passageiros * 100 as
porcentagem_sobreviventes FROM 
acidentes_aereos;
	Respostas:
	a. 
(SELECT quantidade_vitimas_fatais  FROM 
acidentes_aereos) / (SELECT
quantidade_passageiros  FROM  acidentes_aereos)
* 100;
	
	b. 
SELECT porcentagem_sobreviventes FROM
acidentes_aereos;
	
	c. 
SELECT IN acidentes_aereos VALUE
quantidade_vitimas_fatais /
quantidade_passageiros * 100 as
porcentagem_sobreviventes;
	
	d. 
SELECT quantidade_vitimas_fatais FROM
quantidade_passageiros * 100  IN 
acidentes_aereos;
	
	e. 
SELECT quantidade_vitimas_fatais /
quantidade_passageiros * 100 as
porcentagem_sobreviventes FROM 
acidentes_aereos;
	Comentário da resposta:
	e. Para obter a porcentagem de vítimas é preciso dividir, em cada registro, e quantidade de vítimas pela quantidade de passageiros e multiplicar essa proporção por 100.
	
	
	
· Pergunta 10
1 em 1 pontos
	
	
	
	Com a SQL podemos utilizar sub-selects, que são “selects dentro de selects”. Considere o exemplo:
 
> select * from municipio;
+----+------------+------+
| id | nome       | uf   |
+----+------------+------+
|  1 | São Paulo  | SP   |
|  2 | Osasco     | SP   |
|  3 | Mateiros   | TO   |
|  4 | Salvador   | BA   |
+----+------------+------+
 
> select * from municipio where uf = 'SP';
+----+------------+------+
| id | nome       | uf   |
+----+------------+------+
|  1 | São Paulo  | SP   |
|  2 | Osasco     | SP   |
+----+------------+------+
 
> select count(*) from (select * from municipio where uf = 'SP') as subtab;
+----------+
| count(*) |
+----------+
|        2 |
+----------+
 
Considere agora a existência da tabela voos, com um voo por registro e coma coluna data, representando a data do voo.
 
Qual dos seguintes comandos exibe corretamente todos os dados dos voos ocorridos na data do voo mais antigo registrado?
	
	
	
	
		Resposta Selecionada:
	a. 
SELECT * FROM voos WHERE data = (SELECT min(data) FROM voos) as data_mais_antiga;
	Respostas:
	a. 
SELECT * FROM voos WHERE data = (SELECT min(data) FROM voos) as data_mais_antiga;
	
	b. 
SELECT * FROM voos WHERE data = (SELECT min(data)) as data_mais_antiga;
	
	c. 
SELECT * FROM voos WHERE data = min(data);
	
	d. 
SELECT min(data) FROM voos;
	
	e. 
SELECT * FROM voos WHERE min(data);
	Comentário da resposta:
	a. Como queremos ver todas as colunas, é necessário o “SELECT *”. Como queremos ver apenas alguns registros (voos mais antigos) é preciso um WHERE limitando isso, impondo uma condição sobre a data. Se já soubéssemos a data poderíamos fazer algo como “WHERE data = ‘2010-01-01’”, mas no caso podemos trocar o literal ‘2010-01-01’ pela expressão que nele resulta:  “SELECT min(data) FROM voos”.