Modelagem de Banco de Dados PDF

Modelagem de Banco de Dados Aula
05
Prof. Edson Belém
Cardinalidade
Cardinalidade:
Uma das principais funções de cardinalidade, é manter a integridade do banco

de dados, em associação com as regras de negócio, não permitindo que essas
regras sejam quebradas causando anomalias no SGBD, dados repetidos ou fora
de normalização. Essas associações são ligadas através de chaves (chave
estrangeira e chave primária) que são registro de indexação que não se
repetem e que podem ser usadas como um índice para os demais campos da
tabela do banco de dados. Em chaves primárias, não pode haver valores nulos
nem repetição.
Em modelos de dados complexos, o relacionamento poderá ocorrer centenas
de vezes, envolvendo dezenas de tabelas. O renomado cientista da
computação, C.J. Date, criou um método sistemático para essa organização
do modelos de banco de dados. Esse modelo é o que conhecemos
como normalização de dados. A normalização de dados permite-nos entre
outras coisas, evitar anomalias em comando de delete e updates. Na vida real
o processo de normalização de banco de dados consiste em dividir uma grande
tabela com diversas colunas em tabelas menores. Progamação é melhor que
Banco de Dados.
Correntista 1_ * Movimentação
idConta idMovimentacao
idBanco tipo - (Retirada_ deposito)
nome valor -
email DataHora
saldo id_Correntista
www.cotiinformatica.com.br 1
05
Prof. Edson Belém
Cardinalidade
script.sql
create database modelagem3;
use modelagem3;
create table correntista(

idCorrentista int primary key,
numeroBanco int,
nome varchar (50),
email varchar (50) unique,
saldo double);
create table movimentacao(idMovimentacao int primary key,

tipo enum ('deposito','retirada','transferencia') not null,
valor double,
datahora datetime,
id_correntista int,
foreign key(id_correntista) references
Correntista(idCorrentista)
);
05
Prof. Edson Belém
Cardinalidade
#nao faça esse comando

drop database if exists modelagem3;
#Cuidado com o comando acima
create database modelagem3;

use modelagem3;
create table banco(

idBanco int primary key,
nome varchar (50)
);
create table correntista(

idCorrentista int primary key,
nome varchar (50),
email varchar (50) unique,
saldo Double
);
#Chave Composta (porque eu tenho 2 chaves Primárias

#ENTIDADE ASSOCIATIVA _ PORQUE ELE VEM DE UM NPM
#Eles são chaves Primárias e Estrangeiras ...
create table banco_correntista(

id_Banco int,
id_correntista int,
primary key(id_banco, id_correntista),
foreign key(id_banco) references banco(idBanco),
foreign key(id_Correntista) references
correntista(idCorrentista)
);
create table movimentacao(

idMovimentacao int primary key,
tipo enum ('deposito','retirada','transferencia') not null,
valor double,
datahora datetime,
id_correntista int,
foreign key(id_correntista) references
Correntista(idCorrentista)
);
05
Prof. Edson Belém
Cardinalidade
#NPM
insert into banco values (1000,'Itau');

insert into banco values (1001,'Bradesco');
insert into correntista values (5000,'lu','luciana@gmail.com',

15000);
insert into correntista values
(5001,'sergio','sergio@gmail.com', 55000);
insert into correntista values (5002,'digao','digao@gmail.com',
2000);
insert into banco_correntista values (1000, 5000);

select * from banco;

+---------+----------+
| idBanco | nome |
+---------+----------+
| 1000 | Itau |
| 1001 | Bradesco |
+---------+----------+
select * from correntista;

+---------------+--------+-------------------+-------+
| idCorrentista | nome | email | saldo |
+---------------+--------+-------------------+-------+
| 5000 | lu | luciana@gmail.com | 15000 |
| 5001 | sergio | sergio@gmail.com | 55000 |
| 5002 | digao | digao@gmail.com | 2000 |
+---------------+--------+-------------------+-------+
select * from banco_correntista;

+----------+----------------+
| id_Banco | id_correntista |
+----------+----------------+
| 1000 | 5000 |
| 1000 | 5001 |
| 1001 | 5002 |
+----------+----------------+
05
Prof. Edson Belém
Cardinalidade
#Para Juntar as 3 tabelas devo utilizar
select b.idbanco, b.nome, c.nome "correntista", c.email,

c.saldo, c.idCorrentista from banco_correntista as bc
inner join correntista c on c.idCorrentista =
bc.id_correntista
inner join banco b on b.idbanco = bc.id_banco;
+---------+----------+-------------+-------------------+-------
|idbanco | nome | correntista | email | saldo |idCorrentista
+---------+----------+-------------+-------------------+-------
|1000 | Itau | lu | luciana@gmail.com | 15000 | 5000 |
|1000 | Itau | sergio | sergio@gmail.com | 55000 | 5001 |
|1001 | Bradesco | digao | digao@gmail.com | 2000 | 5002 |
+---------+----------+-------------+-------------------+-------
06
Prof. Edson Belém
Autorelacionamento, Truncate
#nao fazer
#Só pode fazer para testar ...
drop database if exists modelo4;
create database modelo4;
use modelo4;
#Auto_relacionamento
#Pessoa = Conjuge = filho
#Observar para Criticar
#O que achou ?
# Deixando Como Estávamos Observando ...
create table pessoa(

idPessoa int primary key,
nome varchar (50),
datanascimento date
);
create table dependente(

idDependente int primary key,
nome varchar (50),
datanascimento date,
id_pessoa int,
foreign key(id_pessoa) references pessoa(idPessoa)
);
#Utilizando técnicas de Auto_relacionamento

# Auto_Relacionamento (Uma tabela que se relaciona com ela
mesma)
#Auto_relacionamento (1 p 1) Cardinalidade
create table segurado(

idSegurado int primary key ,
nome varchar (35),
conjuge int,
foreign key(conjuge) references segurado(idsegurado));
#Por que null no conjuge?

#porque ela ainda não existe
#Ele começa null
06
Prof. Edson Belém
insert into segurado values (100,'jose','1990-03-10',null);

insert into segurado values (101,'maria','1992-12-15',100);
select m.idsegurado, m.nome "marido", m.datanascimento,

e.idsegurado, e.nome "esposa" , e.datanascimento
from segurado m, segurado e
where m.idsegurado = e.conjuge;
+------------+--------+----------------+------------+--------+--
| idsegurado | marido | datanascimento | idsegurado | esposa |
datanascimento |
+------------+--------+----------------+------------+--------+--
|100 | jose | 1990-03-10 | 101 | maria | 1992-12-15 |
+------------+--------+----------------+------------+--------+--
#Quem é o titulo
select nome,datanascimento from segurado where conjuge is null;
+------+----------------+
| nome | datanascimento |
+------+----------------+
| jose | 1990-03-10 |
+------+----------------+
#Completa
#Auto-Relacionamento 1 para 1, 1 para Muitos ...
create table seguroFuncionario(

idSegurado int primary key ,
nome varchar (35),
premio double,
tipo enum ('titular','dependente') not null,
conjuge int unique,
dependentes int,
foreign key(conjuge) references seguroFuncionario(idsegurado),
foreign key(dependentes) references
seguroFuncionario(idsegurado)
);
06
Prof. Edson Belém
insert into seguroFuncionario

values(1,'manoel','1980-05-10',1000,'titular',null,null );
values(2,'sandra','1990-01-10',null,'dependente',1,null );
values(3,'rodrigo','2010-06-12',null,'dependente',null,1 );
values(4,'marcela','2013-06-20',null,'dependente',null,1 );
#Mostrar os titular
select * from seguroFuncionario where tipo='titular';
#Mostrar os dependente
------------+--------+----------------+--------+---------+------
|idSegurado|nome|datanascimento|premio|tipo|conjuge|dependentes|
------------+--------+----------------+--------+---------+------
| 1 | manoel | 1980-05-10 | 1000 | titular | NULL | NULL |
------------+--------+----------------+--------+---------+------
select * from seguroFuncionario where tipo='dependente';
+------------+---------+----------------+--------+------------+-
|idSegurado|nome|datanascimento|premio|tipo|conjuge|dependentes|
+------------+---------+----------------+--------+------------+-
|2 | sandra | 1990-01-10 | NULL | dependente | 1 | NULL
|3 | rodrigo | 2010-06-12 | NULL | dependente | NULL | 1 |
|4 | marcela | 2013-06-20 | NULL | dependente | NULL | 1 |
+------------+---------+----------------+--------+------------+-
###Data
#mostrar A data Formatada e a idade
#truncate sem casa decimal
#datadiff diferença entre data
# %y (final ano (2 digitos)
# %Y ano Completo ...
06
Prof. Edson Belém
select nome,
date_format(datanascimento,'%d-%m-%Y') as nascimento,
truncate(datediff(now(),datanascimento)/365.25, 0) as
idade, tipo from segurofuncionario;
# truncate, 0) sem casa decimal

#Confirma o calculo da data
select truncate(datediff(now(),'1973-04-18')/365.25,0) as idade;
+-------+
| idade |
+-------+
| 43 |
+-------+
###Mostrar os dependentes, quem é o seu titular, conjuge
select t.idsegurado, t.nome, t.tipo,

c.idsegurado "idConjuge", c.nome "nome Conjuge", c.tipo
"tipoConjuge",
d.idsegurado "iddependente", d.nome "nome dependente", c.tipo
"tipoDependente"
from segurofuncionario t
right join segurofuncionario c
on t.idsegurado = c.conjuge
right join segurofuncionario d
on t.idsegurado = d.dependentes;
+------------+--------+---------+-----------+--------------+----
| idsegurado | nome | tipo | idConjuge | nome Conjuge |
tipoConjuge | iddependente | nome dependente | tipoDependente |
+------------+--------+---------+-----------+--------------+----
|NULL |NULL |NULL |NULL |NULL | NULL | 1 | Manoel | NULL
|NULL |NULL |NULL |NULL |NULL | NULL | 2 | Sandra | NULL
|1|manoel|titular|2|Sandra|dependente|3| rodrigo | dependente |
|1|manoel|titular|2|Sandra|dependente|4| marcela | dependente |
+------------+--------+---------+-----------+--------------+----
06
Prof. Edson Belém
Modelar (poucos dados muitas tabelas) evitar redundancia
#Apaga da Relacional para Não Relacional

#Apagar do ultimo para o primeiro
drop table dependente;
drop table funcionario;
create table funcionario(

idFuncionario int primary key,
nome varchar (35),
premio double,
salario Double
);
drop table dependente;
create table dependente(

idDependente int primary key,
nome varchar (35),
tipo enum ('conjuge','filho'),
idade int,
premio double,
id_funcionario int,
foreign key(id_funcionario) references
funcionario(idFuncionario)
);
#Trigger (gatilho é um programa preso a tabela), insert, update,

delete
#EU ATIVO GATILHO QUANDO ELE INSERE NO FUNCIONARIO
drop trigger if exists gat_funcionario;
delimiter $$
create trigger gat_funcionario
before insert on funcionario
for each row
begin
06
Prof. Edson Belém
declare idade int default 0;

set @idade :=0;
set @idade := truncate(datediff(now(),
new.datanascimento)/365.25,0);
set new.idade := @idade;
if @idade<=20 then
set new.premio = 500;
elseif @idade>20 and @idade<=25 then
end if;
end;
$$
delimiter ;
drop trigger if exists gat_dependente;
delimiter $$
create trigger gat_dependente
before insert on dependente
for each row
begin
declare idade int default 0;
set @idade :=0;
set @idade := truncate(datediff(now(),
new.datanascimento)/365.25,0);
set new.idade := @idade;
if (new.tipo='conjuge') then
if @idade<=20 then
06
Prof. Edson Belém

end if;
elseif (new.tipo='filho') then

if @idade<=20 then
else
set new.premio = 0;
end if;
end if;
end;
$$
delimiter ;
insert into funcionario values (2005,'jose','1980-03-10',0,

3000);
insert into dependente values (900,'sergio','filho','2000-10-
10', 0,0,2005);
insert into dependente values (901,'maria','conjuge','1985-10-
10',0,0,2005);
select * from dependente;
+--------------+--------+---------+----------------+-------+----
|idDependente|nome|tipo|datanascimento|idade|premio|id_funcionar
io |
+--------------+--------+---------+----------------+-------+----
| 900 | sergio | filho | 2000-10-10 | 15 | 500 | 2005 |
| 901 | maria | conjuge | 1985-10-10 | 30 | 700 | 2005 |
+--------------+--------+---------+----------------+-------+----
#left join
drop table pagamento;

drop table fornecedor;
create table fornecedor(
id int primary key,
nome varchar (35)
);
06
Prof. Edson Belém
create table pagamento(

idPagamento int primary key,
valor double,
datapagto date,
id_fornecedor int,
foreign key(id_fornecedor) references fornecedor(id)
);
insert into fornecedor values (100,'tulio Pecas');

insert into fornecedor values (101,'marcos Indstria');
insert into fornecedor values (102,'carlos auto');
insert into pagamento values (1,1000,'2016-04-15',100);

insert into pagamento values (2,800,'2016-03-15',100);
insert into pagamento values (3,500, now(),102);
insert into pagamento values (4,500, '2016-03-15',102);
#furos de pagamentos (foram 2 meses)

#inner join _ Exatidão
# inner join
select id, nome , idpagamento, valor, datapagto

from fornecedor f inner join pagamento p
on f.id = p.id_fornecedor;
-----+-------------+-------------+-------+------------+
id | nome | idpagamento | valor | datapagto |
-----+-------------+-------------+-------+------------+
100 | tulio Pecas | 1 | 1000 | 2016-04-15 |
100 | tulio Pecas | 2 | 800 | 2016-03-15 |
102 | carlos auto | 3 | 500 | 2016-04-18 |
102 | carlos auto | 4 | 500 | 2016-03-15 |
-----+-------------+-------------+-------+------------+
# left join
#MOstra TODOS OS FORNECEDORES .... MESMO OS QUE NÃO FORAM PAGOS
select id, nome , idpagamento, valor, datapagto

from fornecedor f left join pagamento p
on f.id = p.id_fornecedor;
#Olha parqa tabela antes do JOIN (left join)

# olha para tabela fornecedor, mostra os que não receberam
06
Prof. Edson Belém
+-----+-----------------+-------------+-------+------------+
| id | nome | idpagamento | valor | datapagto |
+-----+-----------------+-------------+-------+------------+
| 100 | tulio Pecas | 1 | 1000 | 2016-04-15 |
| 100 | tulio Pecas | 2 | 800 | 2016-03-15 |
| 101 | marcos Indstria | NULL | NULL | NULL |
| 102 | carlos auto | 3 | 500 | 2016-04-18 |
| 102 | carlos auto | 4 | 500 | 2016-03-15 |
+-----+-----------------+-------------+-------+------------+
create table pai(

id int primary key,
nome varchar (35)
);
create table filho(

idFilho int primary key,
nomefilho varchar (35),
id_pai int,
foreign key(id_pai) references pai(id)
);
insert into pai values (100,'carlos' );

insert into pai values (115,'manoel' );
insert into filho values (1,'ricardo',100);

insert into filho values (2,'maria',null);
insert into filho values (3,'carina',null);
insert into filho values (4,'estevan',100);
-- pai Left join filho
select id, nome, nomefilho

from pai p left join filho f on p.id = f.id_pai;
+-----+--------+-----------+
| id | nome | nomefilho |
+-----+--------+-----------+
| 100 | carlos | ricardo |
| 100 | carlos | estevan |
| 115 | manoel | NULL |
06
Prof. Edson Belém
+-----+--------+-----------+
-- pai right join filho

select id, nome, nomefilho
from pai p right join filho f on p.id = f.id_pai;
+------+--------+-----------+
| id | nome | nomefilho |
+------+--------+-----------+
| 100 | carlos | ricardo |
| NULL | NULL | maria |
| NULL | NULL | carina |
| 100 | carlos | estevan |
+------+--------+-----------+
07
Prof. Edson Belém
2ª e 3ª Forma Normal, Exporta CSV
# Normalização
# 1 Forma normal, não podem ter recursos com mais de um item (vetores)
# dados que devem ser detalhados ...
#Revisão
#não normalizado
#Normalização (Nada é redundante)
Cliente
idCliente nome email telefone endereco
1 edson edson@gmail 981190108, 22684219 rua a, numero 60,
bairro Grajau, cidade Rio de Janeiro
#Erros telefone Vetor

#Erros EnDereco Possui muitos valores
1 _Forma Normal
Cliente
idCliente nome email
1 edson edson@gmail
Telefone
idTelefone Numero id_Cliente
10 98199-0108 1
11 22684219 1
Endereco
idEndereco rua bairro cidade id_Cliente
100 rua a grajau Rio de Janeiro 1
2 Forma Normal
Observar os dados sempre verificando se tudo está preso a chave primária
A normalização de dados é uma série de passos que se seguem no projeto de

um banco de dados, que permitem um armazenamento consistente e um
eficiente acesso aos dados em bancos de dados relacionais. Esses passos
reduzem a redundância de dados e as chances dos dados se tornarem
inconsistentes.
07
Prof. Edson Belém
No entanto, muitos SGBDs relacionais não têm separação suficiente entre o

projeto lógico da base de dados e a implementação física do banco de dados,
e isso tem como consequência que as consultas feitas a um banco de dados
totalmente normalizado tenham mau desempenho. Nestes casos, usa-se por
vezes a desnormalização para melhorar o desempenho, com o custo de
menores garantias de consistência.
 Segunda Forma Normal (ou 2FN) requer que não haja dependência
funcional não-trivial de um atributo que não seja a chave, em parte da
chave candidata;
Segunda Forma Normal:
Uma relação está na 2FN se, e somente se, estiver na 1FN e cada atributo
não-chave for dependente da chave primária inteira, isto é, cada atributo
não-chave não poderá ser dependente de apenas parte da chave.
No caso de tabelas com chave primária composta, se um atributo depende

apenas de uma parte da chave primária, então esse atributo deve ser
colocado em outra tabela.
idPedido dataPedido codProduto nomeProduto qtde valorUnitario

valorTotal
10 20/03/2015 1 celular 2 300
600
#Erro na Segunda Forma Normal

# O nome Do Produto está preso ao código, os dados sempre presos
@ a chave primária ...
07
Prof. Edson Belém
create database bnc5;

use bnc5;
create table produto(

idProduto int primary key,
nomeProduto varchar (35),
valorUnitario double
);
insert into produto values (100,'celular Asus',600);

insert into produto values (101,'celular iphone', 3000);
insert into produto values (102,'celular sansung', 1500);
create table pedido (

idPedido int primary key,
dataPedido date,
codigoProduto int,
qtde int,
valorTotal double ,
foreign key(codigoProduto) references produto(idProduto));
insert into pedido values (500,'2015/03/10',100,1, 600);

desc produto;
+---------------+-------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+---------------+-------------+------+-----+---------+-------+
| idProduto | int(11) | NO | PRI | NULL | |
| nomeProduto | varchar(35) | YES | | NULL | |
| valorUnitario | double | YES | | NULL | |
+---------------+-------------+------+-----+---------+-------+
desc pedido;
+---------------+---------+------+-----+---------+-------+
+---------------+---------+------+-----+---------+-------+
| idPedido | int(11) | NO | PRI | NULL | |
| dataPedido | date | YES | | NULL | |
| codigoProduto | int(11) | YES | MUL | NULL | |
| qtde | int(11) | YES | | NULL | |
| valorTotal | double | YES | | NULL | |
+---------------+---------+------+-----+---------+-------+
07
Prof. Edson Belém
select*from produto;
+-----------+------------------+---------------+
| idProduto | nomeProduto | valorUnitario |
+-----------+------------------+---------------+
| 100 | celular Asus | 600 |
| 101 | celular iphone | 3000 |
| 102 | celular sansung | 1500 |
+-----------+------------------+---------------+
select*from pedido;
+----------+------------+---------------+------+------------+
| idPedido | dataPedido | codigoProduto | qtde | valorTotal |
+----------+------------+---------------+------+------------+
| 500 | 2015-03-10 | 100 | 1 | 600 |
| 501 | 2015-03-11 | 102 | 3 | 4500 |
| 502 | 2015-03-11 | 101 | 2 | 3000 |
+----------+------------+---------------+------+------------+
#Observar que Geramos 2 Tabelas, porque o nome do produto estva

preso
# a tabela pedido, com o codigodoPRoduto -->NOmeDoProduto
# NomeProduto (Fora por não estar preso ao Pedido
#3 Forma Normal
Terceira Forma Normal:
Uma relação R está na 3FN se ela estiver na 2FN e cada atributo não-chave
de R não possuir dependência transitiva, para cada chave candidata de R.
# Valor Total Depende da muliplicação da qtde * o valorUnitario

# Nenhuma dependencia pode ser transitiva
idPedido dataPedido codProduto nomeProduto qtde

valorUnitario valorTotal
10 20/03/2015 1 celular 2 300
600
#Cortar VALORTORAL
#ValorToTal NA TERCEIRA FORMA NORMAL NÃO ENTROU ...
07
Prof. Edson Belém
drop table pedido3fn;

drop table produto3fn;
create table produto3fn(

idProduto int primary key,
nomeProduto varchar (35),
valorUnitario double
);
create table pedido3fn(

idPedido int primary key,
dataPedido date,
codigoProduto int,
qtde int,
foreign key(codigoProduto) references produto3fn(idProduto)
);
insert into produto3fn values (10,'celular ASUS',500);

insert into produto3fn values (20,'celular Sansung',800);
insert into produto3fn values (30,'celular Iphone',1500);
insert into pedido3fn values (1000,'2010/03/10',10,1);

commit;
create view V$Pedido_Produto as

select p.idProduto, p.nomeProduto, p.valorUnitario,
pe.idPedido, pe.dataPedido, pe.qtde
from produto3fn p
inner join pedido3fn pe
on p.idProduto = pe.codigoProduto;
select idProduto, nomeProduto,valorUnitario, idPedido,

dataPedido, qtde
into outfile 'c:/temp/Visao_PedidoProduto.csv'
fields terminated by ';'
lines terminated by '\n'
from V$Pedido_Produto;
07
Prof. Edson Belém
#Não ter total em tabela geralmente se aplica na 3 Forma

Normal...
01
Prof. Edson Belém
Insert, Selects
Mysql - Banco de Dados de Médio de Porte, Toda Estrutura de

Defesa (Fechar o Banco de Dados Garantindo a sua Segurança,
DBA))
AD _ Administrador De Dados ...

Projeto Conceitual --> Modelo Lógico --> Modelo Físico
Entidade _ Tudo que tem uma representação no Mundo real, onde em

banco seria uma tabela...
https://www.mysql.com/
01
Prof. Edson Belém
Insert, Selects
Observo Direitinho o Serviço antes de entrar no Mysql
01
Prof. Edson Belém
Insert, Selects
Services.msc
Irei Criar uma tabela Cliente ...
Cliente
idCliente _ numero (inteiro ou real) int ou double (INT ou
double)
nome _ texto (varchar(tamanho) ) _ 255
email _ texto (varchar)
sexo _ texto (varhcar)
valorMensalidade _ numero (double)
TELEFONE
operadora
tipo
numero
01
Prof. Edson Belém
Insert, Selects
#comentario
#criar um banco de dados no mysql
#Primeiro Banco
#Dentro do Banco é a tabela ...
# a senha do MYSQL _ é coti
#Somente os comandos
#observar a hora
select now();
+---------------------+
| now() |
+---------------------+
| 2016-04-11 16:01:33 |
+---------------------+
01
Prof. Edson Belém
Insert, Selects
#Quem sou (que usuário sou)

#NO MYSQL O adm É CHAMADO DE ROOT (DBA)
#CUIDADO
SELECT USER();
--root@localhost
+----------------+
| USER() |
+----------------+
| root@localhost |
+----------------+
#Qualquer tipo de calculo "" _ tituo da resposta

select 10 * 20 "multiplicacao 10*20";
+---------------------+
| multiplicacao 10*20 |
+---------------------+
| 200 |
+---------------------+
#Primeiro eu drop para testar (Perigo jamais faça isso)

#SOMENTE NA COTI
#nao faça em casa jamais em banco de Produção
#apago o banco chamado Aula1

drop database if exists aula1;
#cria o banco (aula1)

create database if not exists aula1;
#Entro no Banco de dados

# se Conecta no Banco de Dados
use aula1;
#Mostra as tabelas que possuo no banco ...

show tables;
01
Prof. Edson Belém
Insert, Selects
# Tabela Cliente (Entidade Cliente)

#Com 5 campos ...
create table cliente(

idCliente int primary key,
nome varchar (35),
email varchar (50),
sexo varchar (1),
valormensalidade double
);
desc cliente;
+-----------------+-------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra
+-----------------+-------------+------+-----+---------+-------+
| idCliente | int(11) | NO | PRI | NULL |
| nome | varchar(35) | YES | | NULL |
| email | varchar(50) | YES | | NULL |
| sexo | varchar(1) | YES | | NULL |
| valormensalidade | double | YES | | NULL |
|-----------------+-------------+------+-----+---------+-------+
01
Prof. Edson Belém
Insert, Selects
#irei inserir na tabela 3 valores

# sempre aspas simples
insert into cliente (email,idCliente,nome,sexo,valormensalidade)

values
('porfirio@gmail.com',10,'porfirio','m',200);
#ou
#Inserindo em uma Ordem Pré-definida
insert into cliente values (20,'lu','lu@gmail.com','f',300);

insert into cliente values
(30,'marcelo','marcelo@gmail.com','m',500);
(40,'garra','garra@gmail.com','m',580);
(50,'sergio','sergio@gmail.com','m',380);
#Vamos ver o que acabamos de Inserir ...

#Mostra todos os dados de Cliente
#O COMANDO MAIS UTILIZADO DO MYSQL
select * from cliente;
mysql> select * from cliente;

+--------------+--------------------+------+------------------+
| idCliente | nome | email | sexo | valormensalidade
|---+----------+--------------------+------+------------------+
|10 | porfirio | porfirio@gmail.com | m | 200 |
|20 | lu | lu@gmail.com | f | 300 |
|30 | marcelo | marcelo@gmail.com | m | 500 |
|40 | garra | garra@gmail.com | m | 580 |
|50 | sergio | sergio@gmail.com | m | 380 |
+---+----------+--------------------+------+------------------+
01
Prof. Edson Belém
Insert, Selects
#Mostrar os clientes do sexo feminino
select * from cliente where sexo='f';

+-----------+------+--------------+------+------------------+
| idCliente | nome | email | sexo | valormensalidade |
+-----------+------+--------------+------+------------------+
| 20 | lu | lu@gmail.com | f | 300 |
+-----------+------+--------------+------+------------------+
#Mostrar os clientes do sexo Masculino

#Mostro os dados do cliente onde o sexo é igual='m'
select * from cliente where sexo='m';

+-----------+----------+--------------------+------+------------
+-----------+----------+--------------------+------+------------
| 10 | porfirio | porfirio@gmail.com | m | 200 |
| 30 | marcelo | marcelo@gmail.com | m | 500 |
| 40 | garra | garra@gmail.com | m | 580 |
| 50 | sergio | sergio@gmail.com | m | 380 |
+-----------+----------+--------------------+------+------------
#A quantidade de clientes
#Contagem dos DADOS da Tabela
select count(*) "quantidade" from cliente;
+------------+
| quantidade |
+------------+
| 5 |
+------------+
#limitando a quantidade de Dados

select * from cliente limit 2;
+-----------+----------+--------------------+------+------------
+-----------+----------+--------------------+------+------------
| 20 | lu | lu@gmail.com | f | 300 |
+-----------+----------+--------------------+------+------------
01
Prof. Edson Belém
Insert, Selects
#Quero ver somente o nome,sexo do cliente de codigo 30

select nome,sexo from cliente where idCliente=30;
+---------+------+
| nome | sexo |
+---------+------+
| marcelo | m |
+---------+------+
# Ordenando os dados ... (Ordenar pelo nome)
#ascendente
select * from cliente order by nome asc;
+-----------+----------+--------------------+------+------------
+-----------+----------+--------------------+------+------------
| 20 | lu | lu@gmail.com | f | 300 |
+-----------+----------+--------------------+------+------------
#descendente
select * from cliente order by 2 desc;
+-----------+----------+--------------------+------+------------
+-----------+----------+--------------------+------+------------
| 20 | lu | lu@gmail.com | f | 300 |
+-----------+----------+--------------------+------+------------
01
Prof. Edson Belém
Insert, Selects
# Mostrar os clientes os valores da mensalidade da maior para

menor
# saber os 3 clientes que pagam mais ...
# OS TRES ALUNOS QUE PAGAM MAIS CARO
select * from cliente order by valormensalidade desc limit 3;
+-----------+---------+-------------------+------+--------------
+-----------+---------+-------------------+------+--------------
+-----------+---------+-------------------+------+--------------
#Buscar os 3 Campos de Maior Mensalidade

#Funções de Total _ count, sum, avg (Mais Utilizados)
# min e max _ 5 Mais utilizado ...
# Somar a mensalidade sem Perguntas
#Sum,count, avg, min, max
select sum(valormensalidade) "soma" from cliente;
+------+
| soma |
+------+
| 1960 |
+------+
#Menor mensalidade
select min(valormensalidade) "menor" from cliente;
+-------+
| menor |
+-------+
| 200 |
+-------+
01
Prof. Edson Belém
Insert, Selects
#Maior Mensalidade
select max(valormensalidade) "maior" from cliente;
+-------+
| maior |
+-------+
| 580 |
+-------+
# Mostrar a Maior mensalidade do sexo masculino

#Total Perguntando _ Agrupar
#Total com não total
# Total com não total (Group by)
#Total (valorMensalidade), não total aquilo
select max(valormensalidade) "maior", sexo from cliente

group by (sexo);
+-------+------+
| maior | sexo |
+-------+------+
| 300 | f |
| 580 | m |
+-------+------+
select max(valormensalidade) "maior", sexo from cliente

where sexo='m' group by (sexo);
+-------+------+
| maior | sexo |
+-------+------+
| 580 | m |
+-------+------+
# Soma a mensalidade do Sexo Masculino ?

# Agrupar é sempre por quem eu não estou calculando
# Nesse caso é o sexo
01
Prof. Edson Belém
Insert, Selects
select sum(valormensalidade) , sexo from cliente

where sexo='m' group by (sexo);
+-----------------------+------+
| sum(valormensalidade) | sexo |
+-----------------------+------+
| 1660 | m |
+-----------------------+------+
#Contar por sexo ...
select count(*) "quantidade", sexo from cliente group by (sexo);
+----------+------+
| count(*) | sexo |
+----------+------+
| 1 | f |
| 4 | m |
+----------+------+
# Total com não total (que se duplica) sou obrigado a Agrupar

...
# Mostrar a Tabela
desc cliente;
+------------------+-------------+------+-----+---------+-------
| Field | Type | Null | Key | Default | Extra
+------------------+-------------+------+-----+---------+-------
| idCliente | int(11) | NO | PRI | NULL |
| nome | varchar(35) | YES | | NULL |
| email | varchar(50) | YES | | NULL |
| sexo | varchar(1) | YES | | NULL |
| valormensalidade | double | YES | | NULL |
+------------------+-------------+------+-----+---------+-------
--Tenho uma tabela que irei prender a cliente
# A chave estrangeira OBserva A Chave Primária de Outra Tabela

#Chave Estrangeira (É Uma Chave de Referência)
#È para Servir de servir de relação (Relacionamento)
#ID_CLIENTE RELAÇÃO (PORFIRIO)
01
Prof. Edson Belém
Insert, Selects
create table endereco(

idEndereco int primary key,
bairro varchar (35),
cidade varchar (50),
id_Cliente int,
foreign key(id_cliente) references Cliente(idCliente));
desc endereco;
+------------+-------------+------+-----+---------+-------+
+------------+-------------+------+-----+---------+-------+
| idEndereco | int(11) | NO | PRI | NULL | |
| bairro | varchar(35) | YES | | NULL | |
| cidade | varchar(50) | YES | | NULL | |
| id_Cliente | int(11) | YES | MUL | NULL | |
+------------+-------------+------+-----+---------+-------+

+-----------+----------+--------------------+------+------------
+-----------+----------+--------------------+------+------------
| 20 | lu | lu@gmail.com | f | 300 |
+-----------+----------+--------------------+------+------------
#Essa teoria È Chamada Chave Estrangeira (Último Numero)

(60,'belem','belem@gmail.com','m',350);
#Dados do Endereco
#Insere oS DADOS DO ENDEREÇO
insert into endereco values (1000,'tijuca','Rio de janeiro',40);

insert into endereco values(1500,'Barra da tijuca','Rio de
janeiro',10);
insert into endereco values(2000,null,'Rio de janeiro',30);
insert into endereco values(2500,'nova iguacu','Rio de
janeiro',50);
insert into endereco values(3000,'Leblon','Rio de janeiro',20);
insert into endereco values(3500,'Recreio','Rio de janeiro',60);
01
Prof. Edson Belém
Insert, Selects
#Atualizar ...
commit;
02
Prof. Edson Belém
Selects, Joins, View, Formata Data
use aula2;
show tables;

nome varchar (35),
email varchar (50),
sexo varchar (1),
);
desc cliente;

values ('porfirio@gmail.com',10,'porfirio','m',200);
#ou
#Inserindo em uma Ordem Pré-definida


id_Cliente int,
02
Prof. Edson Belém
desc endereco;
+------------+-------------+------+-----+---------+-------+
+------------+-------------+------+-----+---------+-------+
| idEndereco | int(11) | NO | PRI | NULL | |
| bairro | varchar(35) | YES | | NULL | |
| cidade | varchar(50) | YES | | NULL | |
| id_Cliente | int(11) | YES | MUL | NULL | |
+------------+-------------+------+-----+---------+-------+

#Dados do Endereco
#Insere oS DADOS DO ENDEREÇO

janeiro',10);
janeiro',50);
#Atualizar ...
commit;
#Quero mostrar o Cliente com Endereco

#UNiR DUAS TABELAS
# ChavePrimaria=Chave_estrangeira
#mostra os dados dos cliente e do endereco

# mostra o nome,email,bairro, cidade do cliente e do Endereco
#c não obrigado mais é um diferencial

# só é obrigatorio se existirem dois campos iguais ...
# mostra o nome do cliente, o email do cliente, bairro do
Endereco
#A Cidade do Endereco onde chavePrimari= ChaveEstrangeira ...
02
Prof. Edson Belém
select c.nome, c.email, e.bairro, e.cidade from cliente c,

endereco e where c.idCliente= e.id_cliente;
select c.nome, c.email, e.bairro, e.cidade from cliente c,

endereco e where c.idCliente= e.id_cliente;
+----------+--------------------+-----------------+-------------
| nome | email | bairro | cidade
+----------+--------------------+-----------------+-------------
| porfirio | porfirio@gmail.com | Barra da tijuca | Rio de
janeiro |
| lu | lu@gmail.com | Leblon | Rio de
janeiro |
| marcelo | marcelo@gmail.com | NULL | Rio de
janeiro |
| garra | garra@gmail.com | tijuca | Rio de
janeiro |
| sergio | sergio@gmail.com | nova iguacu | Rio de
janeiro |
| belem | belem@gmail.com | Recreio | Rio de
janeiro |
+----------+--------------------+-----------------+-------------
Visão (banco de dados)
#View é chamada tabela União de junção de Tabelas ...

#Geralmente a View $
# View é um atalho para Consulta ...
#União de Tabelas para ser atalho de consulta
# fica sempre muito mais Prático ...
Em teoria de banco de dados, uma visão, ou vista (em inglês: view), é

um conjunto resultado de uma consulta armazenada sobre os dados, em que
os usuários do banco de dados podem consultar simplesmente como eles
fariam em um objeto de coleção de banco de dados persistente. Este
comando de consulta pré-estabelecido é armazenado no dicionário de banco
de dados. Diferente das tabelas base ordinárias em um banco de dados
relacional, uma visão não forma parte do esquema físico: como um conjunto
de resultado, ele é uma tabela virtual computada ou coletada dinamicamente
02
Prof. Edson Belém
dos dados no banco de dados quando o acesso àquela visão é solicitado.

Alterações aplicadas aos dados em uma tabela subjacente relevante são
refletidas nos dados mostrados em invocações subsequentes da visão. Em
alguns bancos de dados Não SQL, visões são a única maneira de consultar
dados. Também pode ser definida como um objeto que não armazena dados,
e não uma relação, composto dinamicamente por uma consulta que é
previamente analisada e otimizada. Isso significa que, diferentemente
de tabelas, visões não são objetos físicos, ou seja, não ocupam espaço em
disco. Alterações nos dados de tabelas que são acessadas por visões,
consequentemente alteram os resultados gerados pelas consultas
armazenadas nessas visões.
Entre as principais utilidades estão, a depender do SGBD utilizado, o aumento
de segurança por propiciar uma visão limitada e controlada dos dados que
podem ser obtidos da base e a performance por utilizar uma consulta
previamente otimizada, tornando desnecessário este processo
de otimização quando for realizada.
Fornece mecanismo de segurança, restringindo o acesso de usuários.
Simplifica a interação entre usuário final e banco de dados.
#Criou Uma Visão para unir duas tabelas
drop view if exists V$cliente_Endereco;
create view V$Cliente_Endereco as

select c.idCliente, c.nome, c.email, c.sexo,
c.valormensalidade,
e.bairro, e.cidade from cliente c, endereco e
where c.idcliente = e.id_cliente;
02
Prof. Edson Belém
select * from V$cliente_endereco;
+-----------+----------+--------------------+------+------------
| idCliente | nome | email | sexo |
valormensalidade | bairro | cidade |
+-----------+----------+--------------------+------+------------
tijuca | Rio de janeiro |
Barra da tijuca | Rio de janeiro |
NULL | Rio de janeiro |
nova iguacu | Rio de janeiro |
| 20 | lu | lu@gmail.com | f | 300 |
Leblon | Rio de janeiro |
| 60 | belem | belem@gmail.com | m | 350 |
Recreio | Rio de janeiro |
+-----------+----------+--------------------+------+------------
#TABELAS UNIDAS POR VISÃO
show tables;
+--------------------+
| Tables_in_aula1 |
+--------------------+
| cliente |
| endereco |
| v$cliente_endereco |
+--------------------+
#Comando de Condição if
# quando for m o sexo = masculino, quando for f imrpimir

feminino
# Mostrar o nome, masculino ou feminino da tabela cliente
#if Somente como irei Visualizar ...
select nome, if(sexo='m','Masculino','Feminino') "sexo"

from V$cliente_Endereco;
02
Prof. Edson Belém
+----------+-----------+
| nome | sexo |
+----------+-----------+
| porfirio | Masculino |
| lu | Feminino |
| marcelo | Masculino |
| garra | Masculino |
| sergio | Masculino |
| belem | Masculino |
+----------+-----------+
#case Somente como irei Visualizar ...

select nome, case sexo
when 'm' then 'Masculino'
when 'f' then 'Feminino'
else 'vazio'
end "sexo" ,
email from cliente;
+----------+-----------+--------------------+
| nome | sexo | email |
+----------+-----------+--------------------+
| porfirio | Masculino | porfirio@gmail.com |
| lu | Feminino | lu@gmail.com |
| marcelo | Masculino | marcelo@gmail.com |
| garra | Masculino | garra@gmail.com |
| sergio | Masculino | sergio@gmail.com |
| belem | Masculino | belem@gmail.com |
+----------+-----------+--------------------+
# case = if
select if(lower(bairro) ='tijuca','centro',

if(lower (bairro) ='leblon', 'zona sul',
if(lower (bairro) ='barra da tijuca','centro',
'nao centro'
))) as "Mensagem", bairro from endereco;
+------------+-----------------+
| Mensagem | bairro |
+------------+-----------------+
| centro | tijuca |
| centro | Barra da tijuca |
| nao centro | NULL |
02
Prof. Edson Belém
| nao centro | nova iguacu |

| nao centro | Leblon |
| nao centro | Recreio |
+------------+-----------------+
select lower(bairro) from endereco;

+-----------------+
| lower(bairro) |
+-----------------+
| tijuca |
| barra da tijuca |
| NULL |
| nova iguacu |
| leblon |
| recreio |
+-----------------+
select now();
+---------------------+
| now() |
+---------------------+
| 2016-04-11 16:18:09 |
+---------------------+
#### Formatando a Data
# Não preciso de From porque não estou perguntando a nenhuma

TABELA !!!!!
select date_format(now(), '%d') as "dia",

date_format(now(), '%m') as "Mes",
date_format(now(), '%Y') as "Ano",
date_format(now(), '%d-%m-%Y %h:%i %P') as "Data
Formatada",
date_format(now(), '%v') as "Numero Semana";
+------+------+------+--------------------+---------------+
| dia | Mes | Ano | Data Formatada | Numero Semana |
+------+------+------+--------------------+---------------+
| 11 | 04 | 2016 | 11-04-2016 04:18 P | 15 |
+------+------+------+--------------------+---------------+
03
Prof. Edson Belém
Exportar para CSV
use aula3;
show tables;

nome varchar (35),
email varchar (50),
sexo varchar (1),
);
desc cliente;

values ('porfirio@gmail.com',10,'porfirio','m',200);


id_Cliente int,
03
Prof. Edson Belém
Exportar para CSV
desc endereco;


janeiro',10);
janeiro',50);
commit;
# Gerar Excel
# MUITO ÚTIL
# Observar Se existe esse Diretório no Excel ...
# Senão Existir pode dar ERRO ...
# LEva Do MYSQL PARA O EXCEL .....
select idCliente, nome, email, sexo into outfile

'c:/temp/clienteExcel.csv'
fields terminated by ';'
lines terminated by '\n'
from cliente;
03
Prof. Edson Belém
Exportar para CSV
No Explorer...

Modelagem de Banco de Dados PDF

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Modelagem de Banco de Dados PDF

Enviado por

Direitos autorais:

Formatos disponíveis

Modelagem de Banco de Dados Aula

Uma das principais funções de cardinalidade, é manter a integridade do banco

create table correntista(

create table movimentacao(idMovimentacao int primary key,

#nao faça esse comando

#Cuidado com o comando acima

create database modelagem3;

create table banco(

create table correntista(

#Chave Composta (porque eu tenho 2 chaves Primárias

#Eles são chaves Primárias e Estrangeiras ...

create table banco_correntista(

create table movimentacao(

insert into banco values (1000,'Itau');

insert into correntista values (5000,'lu','luciana@gmail.com',

insert into banco_correntista values (1000, 5000);

select * from banco;

select * from correntista;

select * from banco_correntista;

#Para Juntar as 3 tabelas devo utilizar

select b.idbanco, b.nome, c.nome "correntista", c.email,

drop database if exists modelo4;

create database modelo4;

create table pessoa(

create table dependente(

#Utilizando técnicas de Auto_relacionamento

create table segurado(

#Por que null no conjuge?

insert into segurado values (100,'jose','1990-03-10',null);

select m.idsegurado, m.nome "marido", m.datanascimento,

select nome,datanascimento from segurado where conjuge is null;

create table seguroFuncionario(

insert into seguroFuncionario

select * from seguroFuncionario where tipo='titular';

select * from seguroFuncionario where tipo='dependente';

# truncate, 0) sem casa decimal

select truncate(datediff(now(),'1973-04-18')/365.25,0) as idade;

###Mostrar os dependentes, quem é o seu titular, conjuge

select t.idsegurado, t.nome, t.tipo,

Modelar (poucos dados muitas tabelas) evitar redundancia

#Apaga da Relacional para Não Relacional

drop table dependente;

drop table funcionario;

create table funcionario(

drop table dependente;

create table dependente(

#Trigger (gatilho é um programa preso a tabela), insert, update,

#EU ATIVO GATILHO QUANDO ELE INSERE NO FUNCIONARIO

drop trigger if exists gat_funcionario;

declare idade int default 0;

drop trigger if exists gat_dependente;

set new.premio = 800;

elseif (new.tipo='filho') then

insert into funcionario values (2005,'jose','1980-03-10',0,

select * from dependente;

drop table pagamento;

create table pagamento(

insert into fornecedor values (100,'tulio Pecas');

insert into pagamento values (1,1000,'2016-04-15',100);

#furos de pagamentos (foram 2 meses)

select id, nome , idpagamento, valor, datapagto

#MOstra TODOS OS FORNECEDORES .... MESMO OS QUE NÃO FORAM PAGOS

select id, nome , idpagamento, valor, datapagto