Projeto e Implementação de Banco de Dados – Aula 5

Modelo Físico de Banco de Dados

No modelo físico, temos efetivamente a criação do banco de dados em um SGBD,
levando em consideração as limitações impostas pelo programa escolhido e toda a modelagem
lógica feita anteriormente.
Assim como nos tipos anteriores, podemos trabalhar a modelagem física de forma
textual, através da linguagem SQL (Structured Query Language), ou de forma gráfica, utilizando
programas que fazem a posterior criação do código SQL para a criação do banco de dados,
como mostra a imagem abaixo.

Sistemas Gerenciadores de Banco de Dados (SGBD)

A programação de aplicações em computadores sofreu profundas modificações com o
passar dos anos. No início, eram usadas linguagens como C, Fortran, COBOL, Basic, entre
outras, onde os programadores incorporavam em um programa toda a funcionalidade
desejada, desde a interface com o usuário, o processamento dos dados, até o armazenamento
da informação e comunicação com outros sistemas.
Com o passar do tempo, foram sendo identificadas características comuns nos
programas criados, como, por exemplo, o uso de interface gráfica para interagir com o usuário.
Com isso, começaram a ser criadas diversas formas de facilitar o trabalho de criação de
sistemas, como, ainda no caso acima, da interface gráfica, os gerenciadores de interface de
usuário. Além deste, podemos citar os gerenciadores de comunicação, para lidar com a
tranferência de dados com processos remotos, e os sistemas gerenciadores de banco de
dados, para manter as informações. Essa modularização traz várias vantagens, como a
facilidade de manutenção dos sistemas e o aumento de produtividade na hora de criar um
novo programa.
Um SGBD – Sistema Gerenciador de Banco de Dados (DBMS – Database Management
System) é uma coleção de programas que permite criar estruturas, manter dados e gerenciar
as transações efetuadas em tabelas, além de permitir a extração das informações de maneira
rápida e segura.
Algumas das principais características de um gerenciador de Banco de Dados são:
1) Controle de redundância: informações devem possuir um mínimo de redundância
visando estabelecer a estabilidade do modelo;
2) Compartilhamento de dados: as informações devem estar disponíveis para
qualquer número de usuários de forma concomitante e segura;
3) Controle de Acesso: necessidade de saber quem pode realizar qual função dentro
do banco de dados;
4) Esquematização: os relacionamentos devem estar armazenados no banco de dados
para garantir a facilidade de entendimento e aplicação do modelo. A integridade das
informações deve ser garantida pelo banco de dados;
5) Backup ou cópias de segurança: deve haver rotinas específicas para realizar a cópia
de segurança dos dados armazenados.

Os sistemas de banco de dados estão disponíveis em máquinas de pequeno porte até

os computadores de grande porte. Os recursos proporcionados por um determinado sistema
são, até certo ponto, definidos pelo tamanho e pela potência da máquina utilizada.
A segurança é um fator que muito diferencia um banco de dados de outro. As vezes,
há dois bancos de dados que utilizam o SQL como linguagem de acesso e manipulação de
dados, mas que têm estruturas de controle de acesso completamente diferentes. Um
gerenciador de banco de dados deve prever o controle de acesso às informações e garantir por
meio de recursos internos que os dados sejam disponibilizados rapidamente.
Existem diversos SGBDs no mercado. Dentre eles, podemos citar:
• SQL Server: mantido pela Microsoft, é um SGBD pago, lançado em 1988. A versão
mais atual é o SQL Server 2016, utilizável em sistemas operacionais Windows e
Linux
• MySQL: mantido pela Oracle Corporation, é um SGBD que possui recursos
gratuitos, lançado em 1995. Sua versão base estável mais atual é a 5.7, sendo
utilizado, por exemplo, por empresas como o Google, Sony, Cisco, NASA, entre
outros.
• PostgreSQL: um software livre, lançado para a comunidade em 1995, é um SGBD
Objeto-Relacional, atualmente na versão 9.6.1, também multiplataforma, usado
por empresas como Fujitsu e Skype.
• Oracle: mantido pela Oracle Corporation, é um sistema proprietário lançado em
1978. Classificado como um SGBD Objeto-Relacional, atualmente na versão 12c

Outros exemplos de SGBDs: Sybase, Firebird, MariaDB, Microsoft Access, IBM DB2, etc.
Em nossos estudos, utilizaremos o MySQL, mais especificamente, o MySQL
Workbench, uma ferramenta visual para criação de bancos de dados que integra ambiente de
desenvolvimento SQL, modelagem, criação, manutenção e administração de banco de dados.
Ele está disponível nas versões “Community” e “Standard”, e pode ser baixado através do
caminho https://dev.mysql.com/downloads/file/?id=486089.
Iniciando o MySQL Workbench
Para criarmos nosso modelo físico, usaremos o MySQL Workbench. Ao acessá-lo, a
primeira coisa que precisamos fazer é nos conectarmos ao servidor do MySQL instalado. Este
servidor pode estar localizado na própria máquina ou em um computador remoto. O
instalador que vem do site através do link descrito anteriormente nos provê, além do
Workbench, uma instância local do MySQL.

Ao clicarmos no canto superior direito na instância local, os detalhes da conexão

podem aparecer:
 Clicando em qualquer outro lugar da janela, o assistente para conexão será exibido
pedindo a senha. Por padrão, o usuário utilizado se chama “root”. A senha é definida no
momento da instalação do MySQL, então, tome cuidado para não esquecer esta senha.

Após a autenticação, temos acesso à seção de edição do programa:

Na seção onde inserimos os códigos, devemos nos ater a alguns detalhes:

 • Todo comando deve ser encerrado com ponto e vírgula ( ; ). Podemos digitar um
comando em mais de uma linha, mas ao terminá-lo, não podemos nos esquecer
deste encerramento.
• Sempre que quisermos executar alguma coisa, devemos selecionar o que
queremos que seja executado e pressionar Ctrl + Enter, ou, podemos deixar o
cursor na linha que queremos que seja executada, e pressionar Ctrl + Enter.

Outras observações úteis:

• Quando ocorre um erro, a janela de output nos mostra o que está acontecendo.
Leia com cuidado o que aparece nesta seção. Por mais que esteja em inglês, os
termos são relativamente simples de serem compreendidos.
• Essencialmente, no MySQL, Schemas e Databases são a mesma coisa. Em outros
SGBDs, o termo database se refere ao banco de dados como um todo, e o termo
schema se refere a uma parte do banco, mais especificamente, as tabelas e
objetos pertencentes a um usuário.

O que é SQL?
Devido à necessidade de armazenar as informações geradas pelos programas de
computadores, o armazenamento e a recuperação das informações passaram a desempenhar
um papel fundamental na informática. Em junho de 1970, E. F. Codd, membro do Laboratório
de Pesquisa da IBM em San Jose, na Califórnia, publicou um trabalho no jornal Association of
Computer Machinery. Nesse trabalho, Codd estabeleceu princípios sobre gerência de banco de
dados, denominando-os com o termo relacional. Essa foi a base utilizada na criação e uma
linguagem-padrão para manipular informações em bancos de dados relacionais. E essa
linguagem é a SQL (Structured Query Language).
Inicialmente chamada de SEQUEL (Structured English Query Language), a linguagem
SQL foi concebida e desenvolvida pela IBM, utilizando os conceitos de Codd. Em 1979, a
Relational Software Inc., hoje Oracle Corporation, lançou a primeira versão comercial da
linguagem SQL. Atualmente, a SQL pode ser considerada um padrão para manipulação de
dados em banco de dados. Duas entidades, a ANSI (American National Standards Institute) e a
ISO (International Standards Organization), vêm ao longo do tempo padronizando a linguagem
SQL.
Essa linguagem é dividida em quatro partes:
• DDL (Data Definition Language – Linguagem de Definição de Dados): divisão que
permite a criação dos componentes do BD.
• DML (Data Manipulation Language – Linguagem de Manipulação de Dados):
divisão que permite a manipulação (inserção, exclusão, alteração) dos dados.
• DQL (Data Query Language – Linguagem de Consulta de Dados): divisão que
permite a extração/consulta dos dados existentes em um BD.
• DCL (Data Control Language – Linguagem de Controle de Dados): divisão que
controla a segurança do BD.

Cada divisão possui um grupo de comandos, que estudaremos a partir de agora:

Divisão do SQL Comandos

DDL (Data Definition Language) Create Database
Drop Database
Create Table
Drop Table
Alter Table
 Create Index
Drop Index
Alter Index
Truncate
DML (Data Manipulation Language) Insert
Update
Delete
DQL (Data Query Language) Select
DCL (Data Control Language) Grant
Revoke
Create User
Alter User
Create Schema

Modelo de banco de dados base para estudo

Vamos usar um cenário bem simplificado de uma escola para nossos estudos. A ideia é
que nesse modelo possamos controlar quem são os alunos, professores, quais são os cursos,
matérias, as turmas em que os alunos estão inseridos, suas notas, quem são os professores
que lecionam as disciplinas e quais são as matérias que compõem um curso.
Dessa forma, podemos ter como base o seguinte modelo conceitual:

Nota: não temos a pretensão de representar de maneira totalmente fiel o cenário de

uma escola. Isso servirá apenas para fins de estudo.
Fazendo o mapeamento para o modelo lógico, teremos:

R1 – Entidade:
Cursos(cod_curso, nome_curso)
Turmas(cod_turma, nome_turma, periodo_turma)
Alunos(cod_aluno, nome_aluno, sexo_aluno, end_aluno, datanasc_aluno)
Materias(cod_materia, nome_materia, qtde_aulas_semanal)
Professores(cod_prof, nome_prof, sexo_prof, salario_prof, end_prof, datanasc_prof)
R2 – Entidade Fraca: Não se aplica
R3 – Generalização/Especialização: Não se aplica
R4 – Relacionamento 1:1: Não se aplica
R5 – Relacionamento 1:N:
Turmas(cod_turma, nome_turma, periodo_turma, “cod_curso”)
cod_curso referencia Cursos
Alunos(cod_aluno, nome_aluno, sexo_aluno, end_aluno, datanasc_aluno, “cod_turma”)
cod_turma referencia Turmas

R6 – Relacionamento N:N:
Alunos_Materias(“cod_materia”, “cod_aluno”, num_trimestre, nota, qtde_faltas)
cod_materia referencia Materias
cod_aluno referencia Alunos
Cursos_Materias(“cod_curso”, “cod_materia”)
cod_curso referencia Cursos
cod_materia referencia Materias

R7 – Atributo Multivalorado: Não se aplica

R8 – Relacionamento N-ário:
Professores_Materias_Turmas(“cod_materia”, “cod_prof”, “cod_turma”)
cod_materia referencia Materias
cod_prof referencia Professores
cod_turma referencia Turmas

Portanto, o modelo lógico que resultará disso será:

Cursos(cod_curso, nome_curso)
Turmas(cod_turma, nome_turma, periodo_turma, “cod_curso”)
cod_curso referencia Cursos
Alunos(cod_aluno, nome_aluno, sexo_aluno, end_aluno, datanasc_aluno, “cod_turma”)
cod_turma referencia Turmas
Materias(cod_materia, nome_materia, qtde_aulas_semanal)
Professores(cod_prof, nome_prof, sexo_prof, salario_prof, end_prof, datanasc_prof)
Alunos_Materias(“cod_materia”, “cod_aluno”, num_trimestre, nota, qtde_faltas)
cod_materia referencia Materias
cod_aluno referencia Alunos
Cursos_Materias(“cod_curso”, “cod_materia”)
cod_curso referencia Cursos
cod_materia referencia Materias
Professores_Materias_Turmas(“cod_materia”, “cod_prof”, “cod_turma”)
cod_materia referencia Materias
cod_prof referencia Professores
cod_turma referencia Turmas

Enfim, partimos agora para a definição do modelo físico.

Comandos DDL – Criando e eliminando um Banco de Dados

Para criarmos um banco de dados, usamos o comando create database (como é um
equivalente, poderíamos usar create schema no MySQL com o mesmo resultado). Sintaxe do
comando:
 create database <nome_do_banco>;

Por exemplo:

create database teste;

Para excluirmos um banco de dados, usamos o comando drop database (ou drop
schema). Sintaxe do comando:

drop database <nome_do_banco>;

Por exemplo:

drop database teste;

Usando nosso modelo lógico criado anteriormente, vamos definir o banco de dados
agora. Para isso, vamos chama-lo de escola. Portanto, o comando para criar o BD fica:

create database escola;

Para verificar os bancos criados, use o comando show databases.

Não basta criar o banco, precisamos indicar para o MySQL qual banco queremos
utilizar. Fazemos isso através do comando use. Para o banco criado acima, teríamos:

use escola;

Comandos DDL – Criando a estrutura de tabelas

Para criarmos as tabelas em nosso BD Relacional, usamos o comando create table. Sua
sintaxe é um pouco mais complexa, então, vamos analisá-la:

create table <nome_da_tabela> (

<nome_da_coluna_1> <tipo_de_dado> <constraint_da_coluna>,
<nome_da_coluna_2> <tipo_de_dado> <constraint_da_coluna>,
...
<nome_da_coluna_n> <tipo_de_dado> <constraint_da_coluna>,
<constraints_da_tabela>);

Argumento Descrição
<nome_da_tabela> Define o nome da tabela. Deve ser um nome único para o
usuário. Não pode coincidir com o nome de outros objetos do
banco de dados de um mesmo usuário.
<nome_da_coluna> Nome da coluna. Esse nome deve ser único e exclusivo na tabela.
<tipo_de_dado> Tipo de dado que o campo aceita (inteiros, caracteres, datas, etc.)
Abordaremos mais sobre os tipos de dados abaixo.
<constraint_da_coluna> Regras agregadas à coluna
<constraint_da_tabela Regras agregadas à tabela. Falaremos mais sobre as constraints
abaixo.

Por exemplo, poderíamos ter uma tabela definida da seguinte maneira:

 create table usuarios(
cod_usuario integer not null primary key,
nome_usuario varchar(50) not null,
datanasc_usuario date not null
cod_tipo_usuario integer not null,
foreign key (cod_tipo_usuario) references tipo_usuarios(cod_tipo_usuario));

Algumas coisas para notarmos:

• usuarios é o nome que demos para a tabela;
• cod_usuario, nome_usuario, datanasc_usuario e cod_tipo_usuario são os nomes
das colunas;
• integer, varchar, date são tipos de dados;
• not null e primary key são exemplos de constraints de colunas;
• foreign key é um exemplo de constraint da tabela.

Tipos de Dados

Ao ser criada a tabela, é necessário criar a estrutura da mesma, ou seja, definir quais
campos existirão. Para executar tal tarefa faz-se necessário uma análise minuciosa dos
detalhes para qual será utilizado o banco de dados, pois estes deverão ser os dados
preenchidos pelo usuário ao utilizá-lo. Deve ser considerado nesta análise o tamanho que será
utilizado para cada campo, para que não ocorra desperdício de espaço no computador.
Ao se definir um campo é necessário informar qual o tipo de dado será digitado. As
tabelas a seguir têm os tipos de dados usados no MySQL:

TIPOS NUMÉRICOS
Tamanho
Tipo Uso Atributo
Mínimo Máximo
Um inteiro Signed -128 127
TINYINT muito
Unsigned 0 255
pequeno
Um inteiro Signed –32768 32767
SMALLINT
pequeno Unsigned 0 65535
Um inteiro Signed –8388608 8388607
de
MEDIUMINT
tamanho Unsigned 0 16777215
mediano
Um inteiro Signed –2147483648 2147483647
INT or de
INTEGER tamanho Unsigned 0 4294967295
normal
Um inteiro –
de Signed 92233720368547758 9223372036854775807
BIGINT
tamanho 08
grande Unsigned 0 18446744073709551615
Um –3.402823466E+38 –1.175494351E-38, 0
Signed
pequeno 1.175494351E-38 3.402823466E+38
número de
FLOAT Não pode ser unsigned
ponto
OBS Se o número de decimais não for especificado ou
flutuante
for <= 24 será de precisão simples
(precisão
 simples)
Um -
-2.2250738585072014E-
número de 1.7976931348623157E
308, 0
ponto Signed +308
DOUBLE,
flutuante 2.2250738585072014E- 1.7976931348623157E+
DOUBLE
de 308 308
PRECISION,
tamanho
REAL Não pode ser unsigned
normal
OBS Se o número de decimais não for especificado ou
(precisão
for 25 <= Decimals <= 53 será de precisão dupla
dupla)
Se comporta como um campo CHAR:
“descompactado” significa que o número é
armazenado como uma string, usando um
caractere para cada dígito do valor. O ponto
decimal e, para números negativos, o sinal ‘-’ não
Um Signed é contado. Se o decimal for 0, os valores não terão
número de ponto decimal ou parte fracionária.
DECIMAL, ponto O alcance máximo de valores decimais é o mesmo
NUMERIC flutuante que para o DOUBLE, mas a faixa atual para um
descompac campo DECIMAL dado pode ser limitado pela
tado. escolha de comprimento e decimais.
Não pode ser unsigned
Se Decimais é deixado de fora ele é definido como
OBS 0. Se o comprimento é deixado de fora ele é
definido como 10. Note que no MySQL 3,22 o
comprimento inclui o sinal eo ponto decimal

CAMPOS DE DATAS
Tamanho
Tipo Uso
Mínimo Máximo
‘1000-01-01’ ‘9999-12-31’
DATE Datas
Obs: Formato - ‘YYYY-MM-DD’
Data e ‘1000-01-01 00:00:00’ ‘9999-12-31 23:59:59’
DATETIME
horário Obs: Formato - ‘YYYY-MM-DD HH:MM:SS’
‘1970-01-01 00:00:00’ aproximadamente 2037
Obs: Formato - YYYYMMDDHHMMSS, YYMMDDHHMMSS,
YYYYMMDD ou YYMMDD, dependendo se M é 14 (ausente), 12, 8
TIMESTAMP Timestamp ou 6, podendo ser strings ou números.
Este tipo é recomendável para instruções de INSERT ou UPDATE
pois é automaticamente marcado com os valores da operação
mais recente quando não informado.
‘-838:59:59’ ‘838:59:59’
TIME Horários
Obs: formato - ‘HH:MM:SS’, podem ser strings ou números
Anos com 2 1901 2155 e 0000
ou 4 1970 2069
YEAR digitos. O
Obs: Formato - YYYY
padrão é 4
podem ser strings ou números.
digitos
 CAMPOS TEXTO
Tamanho
Tipo Uso
Mínimo Máximo
1 255 caracteres
String de tamanho fixo. Espaços excessivos são removidos quando o
Sempre é completada com valor é trazido.Os valores são ordenados e
CHAR
espaços a direita até o comparados ignorando caixas altas e baixas de
tamanho definido acordo com a codificação padrão, a menos que
seja fornecido uma chave binária.
1 255 caracteres
Os valores são ordenados e comparados
ignorando caixas altas e baixas de acordo com a
VARCHAR String de tamanho variável
codificação padrão, a menos que seja fornecido
uma chave binária.Nota: Espaços execessivos
são removidos quando o valor é inserido.
TINYTEXT 0 255 (2^8 – 1) caracteres
Cadastro de texto livre, 65535 (2^16 – 1)
TEXT 0
com grande quantidade de caracteres
caracteres, como uma 16777215 (2^24 – 1)
MEDIUMTEXT 0
notícia um uma descrição caracteres
de um produto. 4294967295 (2^32 – 1)
LONGTEXT 0
caracteres

DADOS BINÁRIOS
Tamanho
Tipo
Mínimo Máximo
TINYBLOB 0 255 (2^8 – 1) caracteres
65535 (2^16 – 1)
BLOB 0
caracteres
16777215 (2^24 – 1)
MEDIUMBLOB 0
caracteres
4294967295 (2^32 – 1)
LONGBLOB 0
caracteres

LISTAS
Tamanho
Tipo Uso
Mínimo Máximo
String que pode conter apenas um
ENUM Enumeração 65535 valores distintos.
valor ou zero
String que pode conter zero ou
SET Lista 64 itens
mais valores
Constraints (Regras ou Restrições)

As constraints são as regras ou restrições que podemos aplicar a uma coluna ou a uma
tabela. Analisaremos algumas a seguir.

Primary Key

É a coluna, ou grupo de colunas, que permite identificar um único registro da tabela.

Pode ser simples (com apenas um campo) ou composta (com mais de um campo). Podemos
escrevê-la como uma constraint de coluna ou da tabela.

Exemplo 1 – Chave primária simples como constraint de coluna:

create table Clientes(
CPF integer not null primary key,
nome_cliente varchar(50) not null);

Exemplo 2 – Chave primária simples como constraint de tabela:

create table Clientes(
CPF integer not null,
nome_cliente varchar(50) not null,
primary key(CPF));

Exemplo 3 – Chave primária composta:

create table alunos_materias(
cod_aluno int not null,
cod_materia int not null,
media float,
qtde_faltas tinyint,
primary key (cod_aluno, cod_materia),
foreign key (cod_aluno) references alunos(cod_aluno),
foreign key (cod_materia) references materias(cod_materia));

Foreign Key

É o campo que estabelece a relação entre duas tabelas. Sintaxe do comando:

foreign key (nome_da_coluna)

references <nome_da_tabela>(nome_da_coluna_referenciada)

Exemplo:
create table alunos_materias(
cod_aluno int not null,
cod_materia int not null,
media float,
qtde_faltas tinyint,
primary key (cod_aluno, cod_materia),
foreign key (cod_aluno) references alunos(cod_aluno),
foreign key (cod_materia) references materias(cod_materia));
Default, Unique, Not Null, Check e Auto_increment

Default: Usado para definir um conteúdo padrão para uma coluna da tabela, sempre
que uma nova linha for incluída.
Unique: Indica que não pode ocorrer repetição do conteúdo da coluna.
Not Null: Indica que o conteúdo de uma coluna não pode ser nulo.
Check: verifica se um campo atende a uma condição.
Auto_increment: permite que um campo único seja incrementado automaticamente
quando um novo registro é inserido na tabela. Normalmente usado com chave primária.

Exemplo de aplicação de not null, default e unique:

create table clientes(
cod_cliente int not null auto_increment primary key,
nome_cliente varchar(50) not null,
estado_cliente char(2) default 'SP',
CPF_cliente int not null unique,
sexo_cliente char(1),
check (sexo_cliente = 'M' OR sexo_cliente = 'F'));

Criando as tabelas do modelo de exemplo

Voltando ao nosso cenário da escola, temos definido no modelo lógico oito tabelas
para serem criadas. Observe novamente o modelo lógico:

Cursos(cod_curso, nome_curso)
Turmas(cod_turma, nome_turma, periodo_turma, “cod_curso”)
cod_curso referencia Cursos
Alunos(cod_aluno, nome_aluno, sexo_aluno, end_aluno, datanasc_aluno, “cod_turma”)
cod_turma referencia Turmas
Materias(cod_materia, nome_materia, qtde_aulas_semanal)
Professores(cod_prof, nome_prof, sexo_prof, salario_prof, end_prof, datanasc_prof)
Alunos_Materias(“cod_materia”, “cod_aluno”, num_trimestre, nota, qtde_faltas)
cod_materia referencia Materias
cod_aluno referencia Alunos
Cursos_Materias(“cod_curso”, “cod_materia”)
cod_curso referencia Cursos
cod_materia referencia Materias
Professores_Materias_Turmas(“cod_materia”, “cod_prof”, “cod_turma”)
cod_materia referencia Materias
cod_prof referencia Professores
cod_turma referencia Turmas

Analisando os campos acima, antes de criarmos as tabelas, precisamos ter uma ideia
dos tipos de dados que aplicaremos e as restrições que serão aplicadas aos campos e tabelas.
Vamos organizar isso:
• Os campos de código, referentes às chaves primárias das tabelas, ficam melhor
organizados e com melhor desempenho se os definirmos como integer. Além
disso, estes campos de código atuarão como chaves estrangeiras.
• Nome_curso, nome_turma, periodo_turma, nome_aluno, sexo_aluno, end_aluno,
nome_materia, nome_prof, sexo_prof, end_prof são campos que trabalharão com
texto. Como não sabemos a quantidade de caracteres que será digitada, o ideal é
 trabalhar com o tipo varchar. Nos campos de sexo, se quisermos reduzir o espaço
de armazenamento, podemos usar o tipo char com 1 caractere, e podemos
cadastrar os valor ‘M’ para mulheres e ‘H’ para homens.
• Datanasc_aluno, datanasc_prof devem ser do tipo date.
• Qtde_aulas_semanal, num_trimestre, qtde_faltas são referentes a números.
Podemos trabalhar com integer para eles.
• Nota e salario_prof são referentes a valores decimais, portanto, podemos usar o
tipo float.
• Todos os campos são obrigatórios, e devem ter a constraint not null associada.

Portanto:
Tabela Campo Tipo de dado Constraint
cod_curso int Not null, primary key
Cursos
nome_curso varchar(50) Not null
cod_turma int Not null, primary key
nome_turma varchar(10) Not null
Turmas
periodo_turma varchar(10) Not null
cod_curso int Not null, foreign key
cod_aluno int Not null, primary key
nome_aluno varchar(50) Not null
sexo_aluno char(1) Not null
Alunos
end_aluno varchar(50) Not null
datanasc_aluno date Not null
cod_turma int Not null, foreign key
cod_materia int Not null, primary key
Materias nome_materia varchar(50) Not null
qtde_aulas_semanal int Not null
cod_prof int Not null, primary key
nome_prof varchar(50) Not null
sexo_prof char(1) Not null
Professores
salario_prof float Not null
end_prof varchar(50) Not null
datanasc_prof date Not null
cod_materia int Not null, primary key, foreign
key
cod_aluno int Not null, primary key, foreign
Alunos_Materias key
num_trimestre int Not null
nota float Not null
qtde_faltas int Not null
cod_curso int Not null, primary key, foreign
key
Cursos_Materias
cod_materia int Not null, primary key, foreign
key
cod_prof int Not null, primary key, foreign
key
Professores_Materias cod_materia int Not null, primary key, foreign
_Turmas key
cod_turma int Not null, primary key, foreign
key
Programando as tabelas agora, teremos:

-- cria o banco
create database escola;

-- seleciona o banco para uso

use escola;

-- cria a tabela cursos

create table cursos(
cod_curso int not null primary key,
nome_curso varchar(50) not null);

-- cria a tabela turmas

create table turmas(
cod_turma int not null primary key,
nome_turma varchar(10) not null,
periodo_turma varchar(10) not null,
cod_curso int not null,
foreign key (cod_curso) references cursos(cod_curso));

-- cria a tabela alunos

create table alunos(
cod_aluno int not null primary key,
nome_aluno varchar(50) not null,
sexo_aluno char(1) not null,
end_aluno varchar(50) not null,
datanasc_aluno date not null,
cod_turma int not null,
foreign key (cod_turma) references turmas(cod_turma));

-- cria a tabela materias

create table materias(
cod_materia int not null primary key,
nome_materia varchar(50) not null,
qtde_aulas_semanal int not null);

-- cria a tabela professores

create table professores(
cod_prof int not null primary key,
nome_prof varchar(50) not null,
sexo_prof char(1) not null,
salario_prof float not null,
end_prof varchar(50) not null,
datanasc_prof date not null);

-- cria a tabela alunos_materias

create table alunos_materias(
cod_materia int not null,
cod_aluno int not null,
num_trimestre int not null,
nota float not null,
 qtde_faltas int not null,
primary key (cod_materia, cod_aluno),
foreign key (cod_materia) references materias(cod_materia),
foreign key (cod_aluno) references alunos(cod_aluno));

-- cria a tabela cursos_materias

create table cursos_materias(
cod_curso int not null,
cod_materia int not null,
primary key (cod_curso, cod_materia),
foreign key (cod_curso) references cursos(cod_curso),
foreign key (cod_materia) references materias(cod_materia));

-- cria a tabela professores_materias_turmas

create table professores_materias_turmas(
cod_prof int not null,
cod_materia int not null,
cod_turma int not null,
primary key (cod_prof, cod_materia, cod_turma),
foreign key (cod_prof) references professores(cod_prof),
foreign key (cod_materia) references materias(cod_materia),
foreign key (cod_turma) references turmas(cod_turma));

Observações:
• Podemos fazer comentários no código SQL, assim como fazemos em programação.
Para fazer um comentário de linha única, usamos -- e para fazermos comentários
de múltiplas linhas, iniciamos o comentário com /* e terminamos com */. O uso de
comentários é uma boa prática em códigos extensos ou complexos, onde podemos
fazer anotações de coisas que podem ser esquecidas ou que podem nos ajudar na
hora de fazer alguma análise.
• Chaves primárias compostas só podem ser criadas como constraints de tabela.
• O campo que atuará como chave estrangeira deve estar entre parênteses na linha
da declaração da constraint da foreign key.
• Cuidado com a abertura e fechamento de parênteses na hora de fazer os
comandos, e também tome cuidado para não esquecer das vírgulas para separar
um campo de outro, e do ponto e vírgula para terminar o comando de criação da
tabela.
• Para ver as tabelas criadas em um determinado banco, use o comando show
tables.

Comandos DDL – Excluindo a estrutura de tabelas

Para excluir uma tabela (incluindo aí sua estrutura, índices, regras, etc.), usamos o
comando drop table. Veja a sintaxe do comando:

drop table <nome_da_tabela>;

Exemplo:

drop table clientes;

Comandos DDL – Alterando a estrutura de tabelas
Para modificar a estrutura de uma tabela, usamos o comando alter table. Nessas
alterações, podemos inserir ou excluir campos, constraints, ou alterar tipos de dados de
campos. Vamos analisar caso a caso.

Adicionar uma coluna

Sintaxe:

alter table <nome_da_tabela> add <nome_da_nova_coluna> <tipo_de_dado> <constraints>;

Exemplo:

alter table professores add email varchar(50);

Excluindo uma coluna

Sintaxe:

alter table <nome_da_tabela> drop column <nome_da_coluna>;

Exemplo:

alter table professores drop column email;

Alterando uma coluna

Sintaxe:

alter table <nome_da_tabela> modify <nome_da_coluna> <tipo_de_dado> <constraints>;

Exemplo:

alter table cursos modify nome_curso varchar(40) not null;

Adicionando uma restrição de tabela (constraint)

Sintaxe:

alter table <nome_da_tabela> add <constraint>;

Exemplo:

alter table cursos add unique(nome_curso);

Excluindo uma restrição de tabela (constraint)

Sintaxe:

alter table <nome_da_tabela> drop <constraint>;

 Nota: serve apenas para excluir chave primária ou estrangeira.

Renomear colunas

Sintaxe:

alter table <nome_da_tabela> change <nome_atual> <novo_nome> <tipo_de_dado>

<constraints>;

Exemplo:

alter table alunos_materias change nota nota_tri int unsigned not null;

Nota: unsigned é uma constraint usada para permitir somente valores positivos em
uma coluna do banco. Signed permite valores negativos (e é o padrão).

Renomear tabelas

Sintaxe:

alter table <nome_atual_da_tabela> rename <novo_nome_da_tabela>;

Exemplo:

alter table cursos_materias rename materias_cursos;

Comandos DDL – Manipulação de Índices

Índices são indexadores, que trabalham para acelerar a busca por determinadas
informações. Por meio dele, podemos unir uma ou mais colunas onde o acesso é mais
frequente.
Por exemplo, numa tabela de pessoas, pode ser comum querermos fazer buscas em
ordem alfabética. Como o nome não é uma boa chave primária para a tabela (por ser
alfanumérica, o que deixa as pesquisas mais lentas, e pela possível repetição de nomes), então
podemos criar um índice para o nome da pessoa. Dessa forma, mesmo que o nome não seja a
chave primária, o acesso a eles fica mais rápido. Os valores indexados ficam armazenados em
um arquivo do BD, o que permite ao SGBD fazer uma busca primeiro no índice, e depois na
tabela.
Devemos ter cuidado ao usar índices, pois eles consomem espaço em disco (cada
índice cria um novo arquivo para o banco de dados, portanto, quanto mais índices, mais
arquivos). Além disso, quando um índice é criado, o BD deverá mantê-lo atualizado a cada
nova inclusão, exclusão ou alteração de um dado, tornando a operação do banco e
eventualmente de um sistema mais lento.
É recomendável utilizar índices caso algumas rotinas sejam muito utilizadas, como uma
busca de valores ordenados ou quando uma tabela não possuir PK. Em alguns casos não é
recomendável, como quando uma tabela possui muitos valores nulos, muitos valores repetidos
ou em tabelas muito pequenas.
Sintaxe para criação de um índice:

create index nome

on tabela (coluna [, coluna,...] [ASC I DESC]);
 Exemplos:

Create index xAluno

on alunos (nome_aluno);

create index xProfessores

on professores (nome_prof ASC);

Podemos criar um índice com combinações de colunas:

Create index xTurmaPeriodo

on turmas (nome_turma, periodo_turma);

Para excluir um índice, a sintaxe é a seguinte:

Alter table nome_da_tabela

Drop index nome_do_indice;

Exemplo:

Alter table alunos

Drop index xAluno;

Comandos DDL - Truncate

Se quisermos deletar todos os registros de uma tabela, mas não apagar a tabela em si,
podemos usar o comando truncate. Sintaxe:

truncate table nome_da_tabela;

Exemplo:

truncate table alunos;

Trabalho
Usando como base o modelo lógico corrigido da empresa que vocês criaram
anteriormente, faça a codificação para criar o banco de dados e as tabelas utilizando o MySQL.
Vocês deverão entregar o script .sql (o arquivo que fazemos no Workbench) com o código
pronto. Data da entrega: 07/08, via e-mail (yuri.almeida@docente.fieb.edu.br)
Crie todas as tabelas, com todos os campos e chaves necessárias. Consulte este
material para verificar eventuais regras ou tipos de campos que vocês desejem colocar. Na
hora de criar as tabelas, analise cada campo e pense no tipo de dado mais adequado e nas
regras que devem ser associadas a ele (ex: not null, unique, auto_increment, etc.).