Banco de Dados MySQL

MINISTÉRIO DA DEFESA
EXÉRCITO BRASILEIRO
DCT - CITEx
1° CENTRO DE TELEMÁTICA DE ÁREA
(CPD/3 – 1978)
“CENTRO DE TELEMÁTICA LANDELL DE MOURA”
Banco de Dados
MySQL
Seção de Treinamento do 1º CTA
Maio de 2014
Banco de Dados MySQL 2 de 80
Índice
1. Introdução ao SGDB........................................................................................................................3
1.1. O que é o SGBD?......................................................................................................................3
1.2. Sistema de Processamento de Arquivos....................................................................................3
1.3. Características do SGBD..........................................................................................................5
1.4. Transações.................................................................................................................................6
1.5. Tipos de SGBD.........................................................................................................................7
1.6. Modelo de Dados Relacional....................................................................................................7
2. Projeto de Banco de Dados...............................................................................................................9
2.1. Modelagem de dados ...............................................................................................................9
2.2. Modelo Conceitual..................................................................................................................10
2.2.1. Modelo Entidade e Relacionamento ..............................................................................10
2.3. Modelo Lógico........................................................................................................................18
2.3.1. Transformação do Modelo Conceitual em Modelo Lógico............................................19
2.3.2. Normalização..................................................................................................................22
2.4. Modelo Físico.........................................................................................................................25
3. SGBD MySQL...............................................................................................................................26
3.1. O que é o MySQL?.................................................................................................................26
3.2. As principais características do MySQL ................................................................................26
3.3. Instalação do MySQL no Ubuntu...........................................................................................27
3.4. Conectando o MySQL............................................................................................................28
3.5. Prompt do MySQL..................................................................................................................29
4. Comandos SQL ..............................................................................................................................31
4.1. Introdução...............................................................................................................................31
4.2. Tipos de Comandos.................................................................................................................32
4.3. DDL - Linguagem de Definição de Dados ............................................................................33
4.3.1. Criando um Banco de Dados..........................................................................................33
4.3.2. Excluindo um Banco de Dados.......................................................................................34
4.3.3. Criando Tabelas...............................................................................................................35
4.3.4. Alterando a estrutura da tabela........................................................................................42
4.3.5. Excluindo a tabela...........................................................................................................43
4.4. DML - Linguagem de Manipulação de Dados.......................................................................44
4.4.1. Inserindo dados na tabela................................................................................................44
4.4.2. Selecionando dados na tabela..........................................................................................46
4.4.3. Alterando dados na tabela...............................................................................................58
4.4.4. Excluindo dados na tabela...............................................................................................59
4.4.5. Selecionando informações de tabelas diferentes.............................................................59
4.5. DCL - Linguagem de Controle de Dados...............................................................................62
4.5.1. Níveis de Privilégios.......................................................................................................64
4.5.2. Adicionando Novos Usuários..........................................................................................64
4.5.3. Revogando privilégios....................................................................................................65
4.5.4. Removendo Usuários......................................................................................................65
5. Ferramentas de Administração.......................................................................................................67
5.1. PhpMyAdmin .........................................................................................................................67
5.2. Ferramenta de Backup............................................................................................................78
Conclusão...........................................................................................................................................80
Seção de Treinamento do 1º CTA - Maio 2014

1. Introdução ao SGDB
Nesta lição veremos conceitos introdutórios de banco de dados, sua evolução, tipos de banco
de dados e sua importância no dia a dia.
Ao final desta lição têm alguns exercícios para revisar o conteúdo apresentado. São
exercícios simples, cujo conteúdo é explicado no decorrer das lições.
Estude com calma, preste atenção e reproduza os exemplos mostrados.
Bom estudo!
1.1. O que é o SGBD?

Um Sistema de Gerenciamento de Banco de Dados (SGBD - do inglês Data Base
Management System) é uma coleção de dados inter-relacionados e um conjunto de programas para
acessar estes dados. Um conjunto de dados, normalmente referenciado como banco de dados, pode
conter informações sobre por exemplo: uma empresa, clientes, fornecedores, cursos, alunos,
professores, etc. O principal objetivo de um SGBD é prover um ambiente que seja adequado e
eficiente para armazenar e recuperar informações do banco de dados, retirando da aplicação cliente
a responsabilidade de gerenciar o acesso, a manipulação e a organização dos dados.
Os SGBDs são projetados para gerenciar grandes grupos de informações. O gerenciamento
de dados envolve a definição de estruturas para armazenamento de informação e o fornecimento de
mecanismos para manipulá-las. Além disso, o SGBD precisa fornecer segurança às informações
armazenadas, caso o sistema apresente problema, ou contra tentativas de acesso não-autorizado.
1.2. Sistema de Processamento de Arquivos

Antes de surgirem os SGBD, os dados eram armazenados em um Sistema de Processamento
de Arquivos. Para entender como o Sistema funcionava, imagine parte de uma organização bancária
que mantem informações sobre todos os clientes e contas em sistemas de arquivos. O sistema tem
ainda uma quantidade de programas que permite ao usuário manipular os arquivos, incluindo:
• Um programa para adicionar uma nova conta;
• Um programa para calcular o saldo de uma conta;
• Um programa para debitar ou creditar em uma conta;
• Um programa para gerar posicionamentos mensais.

Esses programas são desenvolvidos por programadores em resposta às necessidades desta

organização. Novos programas são adicionados ao sistema à medida que as necessidades aparecem.
Logo, mais arquivos e mais programas são acrescentados ao sistema.
Este típico sistema de processamento de arquivos descrito é suportado por um sistema
operacional convencional. Registros permanentes são guardados em diversos arquivos e outros
programas são escritos para extrair e adicionar registros aos arquivos apropriados. Este esquema
tem uma série de desvantagens:
• Redundância e inconsistência de dados: muitos programadores diferentes e programas
implementados em linguagens diferentes podem gerar arquivos de formatos diferentes.
Informações podem estar duplicadas em diversos lugares. Isto gera inconsistência, pois estas
cópias podem estar com valores diferentes.
• Dificuldade no acesso aos dados: supondo que um diretor deseja a lista de todos os clientes
que moram na cidade com um determinado CEP. Ou ele extrai manualmente esta
informação de uma lista de clientes ou pede a um programador escrever um programa que
faça a busca. Suponha mais tarde que o mesmo diretor deseje uma lista com os clientes com
salário maior que R$5.000. Tal lista não existe e novamente o diretor tem as duas opções.
• Isolamento dos dados: como os dados estão espalhados, em arquivos separados e com
formatos diferentes, é difícil escrever novos programas aplicativos para recuperar os dados.
• Anomalias de acesso concorrente: para aperfeiçoar o desempenho geral do sistema e obter
tempo de reposta mais rápido, deixamos que múltiplos clientes acessem e atualizem os
dados simultaneamente. Isso gera dados inconsistentes. Exemplo: dois clientes sacarem
dinheiro de uma mesma conta corrente ao mesmo tempo.
• Problemas de segurança: nem todo usuário do sistema de BD deve ter acesso a todos os
dados. Por exemplo: o RH pode ter acesso às informações cadastrais dos clientes, mas não
aos valores de conta corrente. Se novos programas aplicativos forem adicionados, é difícil
assegurar tais restrições de segurança.
• Problemas de integridade: os valores dos dados armazenados necessitam satisfazer certas
restrições. Por exemplo, o saldo nunca estar abaixo de R$ 25,00. Estas restrições podem
estar contidas nos programas, mas quando novas restrições forem adicionadas, é difícil de
alterar estes programas.
Por estes motivos foi necessário o desenvolvimento de uma estrutura que evitasse estes
problemas, assim surgiram os SGBDs.

1.3. Características do SGBD

Um SGBD é o conjunto de programas de computador responsáveis pelo gerenciamento das
bases de dados. Seu principal objetivo é retirar da aplicação cliente a responsabilidade de gerenciar
o acesso, a manipulação e a organização dos dados.
Os SGBDs devem possuir mecanismos para definição e manipulação de dados, além de
prover seu compartilhamento e segurança.
Assim, as principais características que um SGBD são:
• Controle de Redundância: A redundância consiste no armazenamento de uma mesma
informação em locais diferentes, provocando inconsistências. Em um Banco de Dados as
informações encontram-se armazenadas em um único local, não existindo duplicação
descontrolada dos dados. Quando existem replicações dos dados, estas são decorrentes do
processo de armazenagem típica do ambiente Cliente Servidor, totalmente sob controle do
Banco de Dados.
• Compartilhamento dos Dados: O SGBD deve ter software de controle de concorrência ao
acesso dos dados, garantindo a escrita/leitura de dados sem erros, em qualquer situação.
• Controle de Acesso: O SGDB deve dispor de recursos que possibilitem definir as
permissões de cada usuário. Assim um usuário poderá realizar qualquer tipo de acesso,
outros poderão ler alguns dados e atualizar outros e outros ainda poderão somente acessar
um conjunto restrito de dados para escrita e leitura.
• Controle de Integridade: Um SGBD deve impedir que aplicações ou acessos pelas
interfaces possam comprometer a integridade dos dados.
• Controle de Concorrência: Método usado para garantir que as transações sejam executadas
de uma forma segura e sigam as regras ACID. Os SGBD devem ser capazes de assegurar
que nenhuma ação de transações completadas com sucesso (committed) seja perdida ao
desfazer transações abortadas (rollback).
• Segurança em Banco de Dados: A segurança do SGBD herda as mesmas dificuldades que
a segurança da informação enfrenta, que é garantir a integridade, a disponibilidade e a
confidencialidade. Um SGBD deve fornecer mecanismos que auxiliem nesta tarefa.
• Backup e Recuperação: O SGBD deve apresentar facilidade para recuperar falhas de
hardware e software, através da existência de arquivos de backup ou de outros recursos,
exigindo minimamente a intervenção de pessoal técnico.

1.4. Transações
A Transação é um conjunto de procedimentos que é executado em um banco de dados, que
para o usuário é visto como uma única ação. A integridade de uma transação depende de quatro
propriedades, conhecidas como ACID (acrônimo de Atomicidade, Consistência, Isolamento e
Durabilidade).
• Atomicidade: Trata o trabalho como parte indivisível (atômico). A transação deve ter todas
as suas operações executadas em caso de sucesso, ou nenhum resultado de alguma operação
refletido sobre a base de dados em caso de falha.
Exemplo: Em uma transferência de valores entre contas bancárias, é necessário que, da
conta origem seja retirado um valor X e na conta destino seja somado o mesmo valor X. As
duas operações devem ser completadas sem que qualquer erro aconteça, caso contrário todas
as alterações feitas nessa operação de transferência devem ser desfeitas;
• Consistência: A execução de uma transição deve levar o banco de dados de um estado
consistente a um outro estado consistente, ou seja, uma transação deve respeitar as regras de
integridade dos dados (como unicidade de chaves, restrições de integridade lógica, etc...).
Exemplo: Considere um banco de dados que guarde informações de clientes e que use o
CPF como chave primária. Então, qualquer inserção ou alteração no banco de dados não
pode duplicar um CPF (unicidade de chaves) ou colocar um valor de CPF inválido, como o
valor 000.000.000-00 (restrição de integridade lógica).
• Isolamento: Conjunto de técnicas que tentam evitar que transações paralelas interfiram
umas nas outras, fazendo com que o resultado da execução de várias transações em paralelo
tenha o mesmo resultado destas mesmas transações sendo executadas sequencialmente (uma
após a outra).
Exemplo: se duas pessoas, simultaneamente, tentarem sacar R$ 100 reais de uma conta que
tem saldo de R$ 100 reais, apenas uma delas deve conseguir executar a operação.
• Durabilidade: Os efeitos de uma transação em caso de sucesso (commit) devem persistir no
banco de dados mesmo que ocorra uma falha depois. A durabilidade garante que os dados
estarão disponíveis em definitivo.
Exemplo: após realizado um saque em um caixa eletrônico, mesmo ocorrendo um problema
no banco de dados, o saldo da conta deve ser o mesmo de antes de ocorrer o problema.

1.5. Tipos de SGBD

Os SGBDs possuem um modelo que define o esquema dos dados armazenados no sistema.
Os quatro modelos de dados mais conhecidos são:
• Hierárquico: é uma coleção de registros que são conectados uns aos outros por meio de
ligações em árvore. Um registro é uma coleção de campos, cada qual contendo apenas um
valor de dados. Uma ligação é uma associação entre exatamente dois registros. O modelo
hierárquico é similar ao modelo de rede, no sentido de que dados e relacionamentos entre
dados são também representados por registros e ligações, respectivamente.
• Em Rede: surgiu como uma extensão ao modelo hierárquico, eliminando o conceito de
hierarquia e permitindo que um mesmo registro estivesse envolvido em várias associações.
No modelo em rede, os registros são organizados em grafos, onde cada registro filho pode
ser ligado a mais de um registro pai, criando conexões bastante complexas. Eles são bastante
utilizados em sistemas para computadores de grande porte.
• Orientado a Objetos: armazena as informação na forma de objetos, ou seja, utiliza a
Estrutura de dados denominada Orientação a Objetos, a qual permeia as linguagens mais
modernas.
• Relacional: define maneiras de armazenar, manipular e recuperar dados estruturados
unicamente na forma de tabelas.
O SGBD que iremos utilizar neste estudo é o MySQL, que é um exemplo de Banco de
Dados Relacional. Vamos entender como foi o processo de desenvolvimento deste tipo de Bando de
Dados.
1.6. Modelo de Dados Relacional

Os princípios do modelo de dados relacional foram descritos por Edgar Frank Codd em
1970 intitulado de "A Relational Model of Data for Large Shared Data Banks".
Os Bancos de Dados Relacionais foram desenvolvidos para prover acesso facilitado aos
dados. Eles podem, por exemplo, armazenar informações dos funcionários de uma empresa, alunos
e professores de uma escola, clientes e fornecedores de uma loja, etc.
Os dados de um Banco de Dados Relacional são armazenados em tabelas. Uma tabela é uma
simples estrutura de linhas e colunas. Em uma tabela, cada linha contém um mesmo conjunto de
colunas. Em um banco de dados podem existir uma ou mais tabelas.

As tabelas associam-se entre si através de regras de relacionamentos. Por exemplo, a tabela

funcionário relaciona-se com a tabela departamento. Através deste relacionamento esta última
tabela fornece a lista de departamentos para a tabela funcionário.
A linguagem padrão dos BD Relacionais é a Structured Query Language (Linguagem de
Consulta Estruturada), ou simplesmente SQL, como é mais conhecida.
Entre os Bancos de Dados Relacionais mais usados atualmente estão: PostgreSQL, Firebird,
DB2 e Oracle.
Antes de construir o banco de dados é preciso definir que informações serão armazenadas.
Para isso, deve-se elaborar um projeto de banco de dados, onde será definida a estrutura deste
banco. Este será o nosso próximo assunto.
Estamos chegando ao final desta lição!

Aqui vimos o que são e como surgiram, as principais características e tipos de SGBDs,
inclusive o Banco de Dados Relacional que é o foco no nosso curso.
Para relembrar os conceitos vistos até agora, vamos fazer alguns exercícios!
Acesse o Portal de Ensino do 1º CTA e faça o Exercício de Revisão da Lição 1.

2. Projeto de Banco de Dados

Nesta lição veremos como montar um projeto de banco de dados, passo importantíssimo
antes de implementarmos o nosso banco de dados no SGBD.
Bom estudo!
2.1. Modelagem de dados

Um banco de dados deve ter sempre um projeto para organizar as informações inseridas e ter
um bom desempenho. Mas, como desenvolver o projeto?
O primeiro passo para o desenvolvimento de um projeto de banco de dados é fazer a
Modelagem de Dados, que é uma técnica usada para a especificação das regras de negócios e das
estruturas de dados de um banco de dados. Ela faz parte do ciclo de desenvolvimento de um sistema
de informação e é de vital importância para o bom resultado do projeto.
Modelar dados consiste em desenhar o sistema de informações, concentrando-se nas
entidades lógicas e nas dependências lógicas entre essas entidades.
A modelagem de dados ou modelagem de banco de dados envolve uma série de aplicações
teóricas e práticas, visando construir um modelo de dados consistente, não redundante e
perfeitamente aplicável em qualquer SGBD.
A modelagem de dados está dividida em três fases:
1. Modelo Conceitual: baseia-se no mais alto nível e deve ser usado para envolver o cliente,
pois o foco é discutir os aspectos do negócio do cliente e não da tecnologia a ser utilizada.
Os exemplos de modelagem de dados vistos pelo modelo conceitual são mais fáceis de
compreender, já que não há limitações ou aplicação de tecnologia específica.
2. Modelo Lógico: leva em conta algumas limitações de tecnologia e implementa recursos
como adequação de padrão e nomenclatura, define as chaves primárias e estrangeiras,
integridade referencial, entre outras. O modelo lógico deve ser criado considerando os
exemplos de modelagem de dados criados no Modelo Conceitual.
3. Modelo Físico: leva em conta as limitações impostas pelo SGBD escolhido e deve ser
criado sempre com base nos exemplos de modelagem de dados produzidos no Modelo
Lógico.

2.2. Modelo Conceitual

No projeto de banco de dados, o primeiro passo é construir o Modelo Conceitual. O modelo
conceitual consiste em descrever de forma resumida os requisitos de dados dos usuários. Ou seja,
como os usuários pretendem guardar seus dados. Para realizar tal descrição resumida, utiliza-se o
Modelo de Entidade Relacionamento (MER). O MER é descrito através do Diagrama Entidade
Relacionamento (DER) que possui uma simbologia própria.
O Modelo Conceitual é o processo de construir um banco de dados em termos do DER:
• Entidades: são representados por retângulos contendo conjuntos de itens de informação;
• Relacionamentos: são representadas por ligações entre as entidades relacionadas.
2.2.1. Modelo Entidade e Relacionamento

O Modelo de Entidade e Relacionamento (MER) é um modelo abstrato cuja finalidade é
descrever, de maneira conceitual, os dados a serem utilizados em um sistema de informações. A
principal ferramenta do modelo é sua representação gráfica, o Diagrama Entidade Relacionamento
(DER), que é a forma pela qual um projetista de banco de dados descreve os requisitos levantados
pelos clientes.
O MER foi proposto por Peter Chen, em 1976, e possibilita ao projetista concentrar-se na
utilização dos dados sem se preocupar com a estrutura lógica de tabelas. Por esse motivo, o MER é
utilizado pelo modelo conceitual para modelar o banco de dados de forma independente do SGDB.
Vale ressaltar que existem várias formas de representar graficamente o MER, algumas
desenvolvidas em centros de pesquisa, outras fruto de padrões estabelecidos por fabricantes de
ferramentas e ainda resultados de trabalhos acadêmicos somados ou modificados pelas diferentes
formas de implementação adotadas pelos produtores das ferramentas de modelagem. Aqui iremos
utilizar a nomenclatura criada por Peter Chen.
2.2.1.1. Entidade
A Entidade é um objeto no mundo real que pode ser identificado de forma única em relação
aos outros objetos.
Sabendo o que são as entidades, tente identificar quais são as entidades do exemplo a seguir.

Suponha que uma empresa chamada ABC pede para desenvolver um software para gerenciar
seus empregados. Durante a fase de entrevistas, pode-se perguntar o que a empresa deseja
armazenar. Uma possível resposta da empresa será informações sobre empregados e os
departamentos.
Assim, podemos identificar as entidades do nosso MER: Empregado e Departamento.

Depois de identificar as entidades, é necessário modelá-las no DER. No DER, as Entidades
são representadas por retângulos e seu nome é escrito no centro deles, como mostrado na Figura
a seguir. Nesta figura, temos as duas entidades identificadas no exemplo.
EMPREGADO DEPARTAMENTO
Figura 1: Entidades representadas por Retângulos no DER
2.2.1.2. Atributo
Note que, até o momento, as entidades não guardam informação alguma. Elas apenas
representam um objeto existente no cenário da empresa. Para guardar informação, deve-se definir
os atributos das entidades. Dessa forma, atributos são propriedades particulares que descrevem cada
entidade.
Para entender melhor o que são atributos, vamos voltar ao exemplo da empresa ABC.
Para identificar os atributos de uma entidade, deve-se perguntar ao cliente: que informações
precisam ser guardadas sobre os empregados: Uma possível resposta seria: Código, Nome,
Salário, Data de Admissão e Data de Demissão. Essas informações guardadas pela empresa
sobre os empregados são os atributos da entidade Empregado.
No DER, o Atributo é representado por uma elipse que possui escrito no centro o seu
nome e é ligado à entidade através de uma linha.
A Figura a seguir ilustra um exemplo da entidade Empregado e seus atributos: cod_emp
(código identificador do empregado), nome (nome completo do empregado), salario (salário atual
do empregado), data_admissao (data que o empregado foi admitido na empresa) e data_demissão
(data que o empregado foi demitido, caso não tenha sido, fica sem valor).

nome salario data_admissao
cod_emp data_demissao
EMPREGADO
Figura 2: Atributos da entidade Empregado
Para representar todas as informações de uma entidade, os atributos são classificados como:
• Atributo simples: são chamados também de atributos atômicos, não são divisíveis. Por
exemplo, a entidade Empregado, tem os seguintes atributos simples: cod_emp, nome e
salario.
• Atributo composto: podem ser divididos em partes menores, ou subpartes, os quais

representariam atributos básicos mais simples com significados independentes. Exemplo:
em algumas empresas, o atributo Endereço é composto por informações, como: Rua,
Número, Bairro e CEP.
A Figura a seguir mostra como um atributo composto Endereço é representado no DER.
numero bairro
rua cep
endereco
EMPREGADO
Figura 3: Atributo composto representado no DER
• Atributo multivalorado: quando possuem um ou mais valores. Exemplo: Telefone. Um

empregado poderá ter mais de um número de telefone.
A Figura a seguir mostra como o atributo multivalorado Telefone é representado no DER.

Nesse caso, um empregado pode ter mais de um telefone, tais como: casa, trabalho, celular etc.
endereco
telefone
EMPREGADO
Figura 4: Atributo multivalorado representado no DER
• Atributo chave: um aspecto importante no conceito de entidade e atributos é a possibilidade

de individualização de cada um dos objetos representados na entidades. Como exemplo,
pode-se dizer que todo empregado da empresa possui um código. Através dele, é possível
identificar cada um dos indivíduos (distintos) sem risco de ambiguidades ou confusão. Isso
porque, se dois empregados podem ter o mesmo salário ou até nomes idênticos, o código de
identificação é sempre único e não pode se repetir. Um exemplo de atributo chave que nunca
se repete são os atributos CPF, RG ou cod_emp de um empregado.
A Figura a seguir mostra como o atributo chave cod_emp é representado no DER.
cod_emp
EMPREGADO
Figura 5: Atributo chave representado no DER
Depois de definir as entidades e atributos, é preciso relacionar as entidades de um MER. O

relacionamento de entidades é importante porque os dados de um banco de dados nunca estão
isolados.
Por exemplo, um empregado está ligado a um departamento em uma empresa. Um curso
tem alunos. Um professor leciona cursos. A seguir, será mostrado como definir relacionamentos
entre as entidades.

2.2.1.3. Relacionamento
Existem basicamente três tipos de relacionamentos, sendo que os tipos de relacionamentos
determinam como as entidades se relacionam. Cada tipo de relacionamento define uma restrição
diferente para as entidades envolvidas.
O Relacionamento entre entidades em um DER é representado através de um losango
que liga as entidades relacionadas. A Figura a seguir ilustra um exemplo de relacionamento entre as
entidades Empregado e Departamento.
empregado aloca departamento
Figura 6: Relacionamento representado no DER
Para identificar como cada entidade se relaciona com as demais, é importante fazer algumas
perguntas ao cliente.
Para identificar os relacionamentos da empresa ABC pode-se perguntar: Como um empregado

está relacionado com um departamento: Um empregado pode trabalhar em apenas um
departamento? Um departamento possui mais de um empregado?
Dependendo da resposta fornecida pelo cliente, o relacionamento poderá ser do tipo:

• um-para-um (1:1)
O relacionamento um-para-um é usado quando uma entidade A se relaciona com apenas uma
entidade B e vice-versa. Esse relacionamento é representado pelo sinal: 1:1.
Por exemplo, se um professor lecionasse aula para apenas um curso e um curso pode ser
lecionado por apenas um professor, esse é um relacionamento um-para-um porque a entidade
professor leciona um curso e um curso é lecionado por apenas um professor. Observe que o fato
de um professor lecionar um curso é uma restrição deste caso que foi identificada na entrevista.
Outras escolas podem ter vários professores lecionando um ou vários cursos. Para estas, o
relacionamento não seria 1:1.
1 1
professor leciona curso
Figura 7: Relacionamento um-para-um no DER

• um-para-muitos (1: N ou N:1)

O relacionamento um-para-muitos é usado quando uma entidade A pode se relacionar com
uma ou mais entidades B. Esse relacionamento é representado pelo sinal: 1:N ou N:1.
Por exemplo, em entrevista com a empresa ABC, foi informado que um departamento pode ter
vários empregados e um empregado está associado a apenas um departamento. Esse é um
relacionamento um-para-muitos porque a entidade Departamento possui vários Empregado. Por
outro lado, cada Empregado está associado a apenas um Departamento.
N 1
Figura 8: Relacionamento um-para-muitos no DER
Lê-se:
• Um empregado está alocado em UM departamento;
• Um departamento aloca N (vários) empregados.
• muitos-para-muitos (N:N)
O relacionamento muitos-para-muitos é usado quando várias entidades A se relacionam com
várias entidades B. Esse relacionamento é representado pelo sinal: N:N ou N:M.
Por exemplo, um curso pode ter vários alunos e um aluno pode fazer vários cursos. Este é
um relacionamento muitos-para-muitos, porque a entidade curso pode ter vários (M) alunos. Por
outro lado, cada aluno pode fazer vários (N) cursos.
N M
curso matricula aluno
Figura 9: Relacionamento muitos-para-muitos no DER
Depois de definir o relacionamento entre as entidades é preciso identificar a cardinalidade

dos relacionamentos.

2.2.1.4. Cardinalidade
A cardinalidade é um conceito importante para ajudar a definir o relacionamento, ela define
o número de ocorrências em um relacionamento.
Para determinar a cardinalidade, deve-se fazer algumas perguntas relativas ao
relacionamento em ambas às direções. Por exemplo, dado um relacionamento entre Departamento e
Empregado, pode-se fazer as seguintes perguntas:
Pergunta 1: Um empregado está alocado em quantos departamentos?
Resposta 1: No mínimo em 0 (empregado desligado da empresa) e no máximo em 1.
Pergunta 2: Um departamento aloca quantos empregados?
Resposta 2: No mínimo 1 e no máximo N (muitos).
De acordo com as respostas anteriores, temos que a cardinalidade expressa no

relacionamento:
• pelo lado da entidade Empregado é 0:1; e
• pelo lado da entidade Departamento é 1:N.
A figura a seguir, mostra esta representação.
N 1
(1:N) (0:1)
Figura 10: Exemplo de cardinalidade
Observe que a resposta é dada na forma de “no Mínimo” e “no Máximo”. Por tais termos
serem usados, surgiu o conceito de Cardinalidade Máxima e Cardinalidade Mínima. As
cardinalidades são expressas pela forma (Cardinalidade Mínima : Cardinalidade Máxima).
Exemplo: (1:N) e (1:1).
A cardinalidade máxima indica a quantidade máxima de ocorrências de entidades que
podem estar associadas a uma ocorrência da outra entidade. Dessa forma, duas cardinalidades
máximas são relevantes:
• a cardinalidade máxima 1;
• a cardinalidade máxima “muitos” representada pela letra N.

Como exemplo, a entidade Empregado, que tem cardinalidade máxima 1 no seu relacionamento
com uma ocorrência da entidade Departamento. Ou seja, o empregado só pode estar alocado em no
máximo um departamento. Por outro lado, a entidade Departamento tem cardinalidade máxima de
N. Isto é, um departamento pode alocar um número N infinito de empregados trabalhando nele.
Por sua vez, a cardinalidade mínima especifica se a participação de todas as ocorrências

das entidades no relacionamento é obrigatória ou opcional. Em um projeto de BD, é usada somente
duas cardinalidades mínimas: a cardinalidade mínima 0 e a cardinalidade mínima 1.
A cardinalidade mínima 1 recebe a denominação de “associação obrigatória”, é obrigado ter
a cardinalidade mínima. A cardinalidade mínima 0 recebe a denominação de “associação opcional”.
Como exemplo, a entidade Empregado, que tem cardinalidade mínima 1 no seu relacionamento
com uma ocorrência da entidade Departamento. Ou seja, o empregado pode estar alocado a
nenhum departamento (no caso de estar desligado da empresa). Por outro lado, a entidade
Departamento tem cardinalidade mínima de 1. Isto é, um Departamento deve alocar pelo menos
um Empregado.
Vamos ver como ficou nosso DER completo.
cod_emp nome cod_dep nome
N 1
(1:N) (0:1)
salario data_admissao data_demissao
Figura 11: DER da empresa ABC
Nosso Modelo Conceitual está concluído!

Vamos construir agora o Modelo Lógico.

2.3. Modelo Lógico

O Modelo Lógico é uma transição entre o Modelo Conceitual e o Modelo Físico. Ou seja,
saímos do Modelo Conceitual independente de SGDB para o Modelo Físico no qual algumas
limitações do SGDB devem ser consideradas. O SGDB que vamos utilizar é o MySQL.
Como vimos, no Modelo Conceitual, os dados do BD Relacional são representados na forma
de Entidades e Relacionamentos. Na transição Modelo Conceitual para o Modelo Lógico:
• Entidades se transformam em Tabelas
◦ Tabela é a forma como toda a informação de um banco de dados relacional é
armazenada. Por exemplo, pode-se ter uma tabela Empregado, onde são armazenadas
informações sobre os diversos empregados.
• Atributos se transformam em Colunas (ou Campos)
◦ Colunas são todas as informações que existem em uma tabela. Por exemplo: Nome, CPF,
Rua, Bairro, Telefones, CEP, Data de Nascimento, etc.
• Domínio (Tipo de Dado)
◦ Toda coluna para armazenar as informações de uma tabela deve ter um domínio
definido. O domínio representa todos os valores possíveis que uma coluna pode receber.
Por exemplo, a coluna Telefone pode receber um conjunto de número com oito dígitos.
Por outro lado, a coluna Nome pode receber um conjunto de cadeias de caracteres que
representa o nome de uma pessoa. Desse modo, o domínio de uma coluna define qual o
tipo de dado e o formato que o dado pode ser armazenado.
• Tuplas (Registros ou Linhas)
◦ As tuplas representam os valores armazenados em uma tabela, também chamada das
linhas da tabela.
A figura a seguir mostra uma tabela Cliente preenchida com valores hipotéticos. Note que as
colunas da tabela representam os atributos, enquanto as linhas (ou registros) representam as tuplas.
Se uma tabela não tiver tuplas, ela estará vazia, ou seja, sem dados.

TUPLA
TABELA
Figura 12: Os atributos e as tuplas de uma tabela Cliente
2.3.1. Transformação do Modelo Conceitual em Modelo Lógico

Para transformar o Modelo Conceitual em Modelo Lógico, vamos usar o exemplo da
empresa ABC. Na Figura 11, é mostrado o DER deste exemplo.
Para transformá-lo no Modelo Físico:
1) Identifique as entidades:
empregado
departamento
2) Identifique as colunas que são chave identificadora da tupla e sublinhando-o.

empregado (cod_emp)
departamento (cod_dep)
3) Defina o tipo de dados que cada coluna irá armazenar.

empregado departamento
cod_dep: número inteiro
cod_emp: número inteiro
nome: caracteres (máximo 40)
nome: caracteres (máximo 90)
salario: número real
data_admissao: data
data_demissao: data

4) A partir da cardinalidade dos relacionamentos, aplique as regras a seguir:

• Relacionamento 1:1 - dentre as relações que mapeiam as entidades participantes escolha
uma delas e inclua como chave estrangeira a chave primária da outra. Exemplo:
1 1
professor leciona curso
Figura 13: Relacionamento um-para-um no DER

professor (cod_prof, nome, endereco, data_admissao)
curso (cod_curso, nome, carga_horaria, #cod_prof)
Sendo a coluna cod_prof da tabela curso chave estrangeira (representada pelo caractere #) para a
tabela professor.
• Relacionamento 1:N - escolha a relação que representa a entidade presente no lado N, e

acrescente como chave estrangeira a chave primária da entidade do lado 1. Exemplo:
N 1
Figura 14: Relacionamento um-para-muitos no DER

departamento (cod_dep, descricao)
empregado (cod_emp, nome, salario, data_admissao, data_demissao, #dep_id)
Sendo a coluna dep_ip da tabela empregado chave estrangeira para a tabela departamento.
• Relacionamento N:M - é criada uma nova relação contendo como chaves estrangeiras as
chaves primárias das entidades participantes, mais os atributos do relacionamento. Exemplo:
N M
curso matricula aluno
Figura 15: Relacionamento muitos-para-muitos no DER

aluno (cod_aluno, nome, data_nasc, endereco)
curso (cod_curso, nome, carga_horaria, #cod_prof)
matricula (#cod_aluno, #cod_curso, data)
Sendo as colunas cod_aluno e cod_curso da tabela matricula chave estrangeira para as,
respectivas, tabelas aluno e curso.

No Modelo Lógico, foram apresentadas duas novas estruturas: a Chave Primária e a

Chave Estrangeira.
• A Chave Primária é a coluna da tabela que identifica a tupla (registro) de forma única. Os
dados da chave primária devem ser únicos e não devem haver dois ou mais registros que
possuam os mesmos dados armazenados na coluna que for a chave primária. Na tabela
departamento, a chave primária é a coluna cod_dep. Uma chave primária pode ser
formada juntando-se mais de uma coluna da tabela. É o caso da tabela Matricula, onde a
chave primária é composta pelas colunas cod_aluno e cod_curso.
• A Chave Estrangeira é uma referência (ligação) com outra tabela. Na tabela empregado,
a coluna cod_emp é a chave primária e a coluna dep_id é uma chave estrangeira. Neste
caso, a chave estrangeira serve para referenciar o departamento que o empregado está
alocado, por isso ela contém esta referencia (chave estrangeria) à chave primária da tabela
departamento. Como cada departamento tem um código de identificação único, fica fácil
descobrir quais empregados estão em cada departamento e também em qual departamento
o empregado está alocado. Uma Chave Estrangeira deve sempre fazer referência a
Chave Primária da tabela pai. Neste exemplo, a tabela pai é a tabela departamento.
Existem ainda outras duas estruturas que já podem ser definidas no Modelo Lógico:
• Índice Único: é um índice onde cada valor é diferente dos demais (não permite
duplicidade) e identifica uma única linha na tabela. Pode conter valores NULL.
• Índice Não-Único: é um índice que permite a repetição de valores, são usados com colunas
que são muito usados para operações de busca e ordenação no banco de dados.
Indexar uma tabela, ou seja, definir índices para certas colunas acelera o desempenho do
banco de dados. Porém, determinar as colunas que serão indexadas, nem sempre é uma escolha
óbvia. Mas podemos considerar um candidato a índice, colunas bastante usadas em pesquisas e em
ordenação dos dados.
É claro que o bom senso deve falar mais alto, pois se forem usados índices demais isto
pode ter consequências indesejáveis. Se a aplicação tiver uma intensa inclusão/alteração de dados,
o uso de muitos índices aumenta o tempo de inclusão e atualização no banco de dados, visto que
todos os índices devem ser atualizados. Neste caso, deve-se limitar aos índices que são realmente
necessários.

Com a adição da chave estrangeira na tabela empregado (coluna dep_id) e definindo que as
colunas nome e salario da tabela empregado são índices não-únicos (marcados com • ) e que a
coluna nome da tabela departamento é um índice único (marcado com - ), o Modelo Lógico da
empresa ABC fica:
empregado departamento
cod_dep: número inteiro
cod_emp: número inteiro
- nome: caracteres (máximo 40)
• nome: caracteres (máximo 90)
• salario: número real
data_admissao: data
data_demissao: data
#dep_id: número inteiro
Com o Modelo Lógico construído pode-se implementar o Modelo Físico, que consiste em
criar as tabelas com seus respectivos atributos no banco de dados.
Porém, antes disso, é uma boa prática executar alguns testes para minimizar as chances de
erro. Para isso, é recomendado que se aplique as regras da Normalização.
2.3.2. Normalização
Os BD Relacionais utilizam a normalização de dados para evitar redundâncias e possibilitar
um maior desempenho nas pesquisas. A Normalização é o processo de organização eficiente dos
dados dentro de um banco de dados, cujos objetivos principais são:
• Eliminar dados redundantes, por exemplo, armazenando os mesmos dados em mais de uma
tabela.
• Garantir que as dependências entre os dados façam sentido, armazenando apenas dados
logicamente relacionados em uma tabela.
Existem cinco estágios de normalização: 1º, 2º, 3º, 4º e 5º. Para um banco de dados
encontrar-se em cada um desses estágios ou formas (denominadas formas normais), cada uma das
tabelas deve atender a alguns pré-requisitos. Os pré-requisitos são cumulativos, isto é, para alcançar
a 3ª forma normal (3NF), um banco de dados precisa atender aos pré-requisitos das 1ª e 2ª formas
normais, acrescidos dos requisitos exclusivos da 3NF.
Antes de vermos os requisitos das formas normais é preciso entender o conceito de
dependência funcional.

2.3.2.1. Dependência Funcional

Um atributo B possui uma dependência funcional do atributo A se, para cada valor do
atributo A, existe exatamente um único valor do atributo B. A dependência funcional é representada
por A → B. Exemplo:
Cliente
CPF Nome
1 José
2 João
3 Rui
4 Manoel
Observe que existe uma dependência entre os valores dos conjuntos, ou seja, nome está em
função do CPF. Ou seja, tendo o CPF, pode-se encontrar o nome da pessoa correspondente.
Essa dependência é expressa por: CPF → Nome
Leia-se: com um número de CPF é possível encontrar o nome da pessoa, ou o nome depende da
funcionalidade do CPF.
2.3.2.2. Primeira Forma Normal (1FN)

Uma relação está na Primeira Forma Normal se os valores de seus atributos são atômicos
(simples, indivisíveis) e monovalorados. Em outras palavras, 1FN não permite “relações dentro de
relações” ou “relações como atributos de tuplas”.
Uma tabela está na Primeira Forma Normal quando seus atributos não contêm grupos de
repetição.
Um exemplo de uma tabela que não atenda o critério para 1FN é:
Cliente
ClienteID Nome Telefone
123 Maria de Souza 861-2025
456 Ana Correa 403-1659 / 776-4100
789 Pedro Soares 808-9633 / 145-7899
Esta tabela não está na Primeira Forma Normal porque apresenta grupos de repetição
(possibilidade de mais de um telefone por cliente).
Já as tabelas abaixo, Cliente e Telefone, estão na primeira forma normal.

Tabela Cliente Tabela Telefone

Cliente Telefone
ClienteID Nome ClienteID Telefone
123 Maria de Souza 123 861-2025
456 Ana Correa 456 403-1659
789 Pedro Soares 456 776-4100
789 808-9633
789 145-7899
Note que foi necessário dividir a tabela Cliente em duas: Cliente e Telefone.
2.3.2.3. Segunda Forma Normal (2FN)

Uma relação está na 2FN quando duas condições são satisfeitas:
1. A relação está na 1FN;
2. Todo atributo da tabela seja dependente funcional da chave completa e não de parte da
chave. Ou seja, todos os atributos não-chave dependem funcionalmente da chave primária.
Um exemplo de uma tabela 1FN que não atende o critério para 2FN é:
Venda
n_pedido n_produto produto quant valor_unit subtotal
23560 0045 Caderno 3 R$ 8,99 R$ 26,97
58741 1025 Folhas A4 10 R$ 12,99 R$ 129,90
Esta tabela não está na Segunda Forma Normal porque a coluna produto depende
funcionalmente da coluna n_produto (não chave primária). Portanto para atender a Segunda Forma
Normal, a mesma informação deveria ser dividida em duas tabelas:
Produto
n_produto produto
0045 Caderno
1025 Folhas A4
Venda
n_pedido #n_produto quant valor_unit subtotal
23560 0045 3 R$ 8,99 R$ 26,97
58741 1025 10 R$ 12,99 R$ 129,90

2.3.2.4. Terceira Forma Normal (3FN)

Uma relação está na 3FN quando duas condições são satisfeitas:
1. A relação está na 2FN;
2. Todos os atributos que não pertencem a chave sejam mutuamente independentes.
Um exemplo de uma tabela 2FN que não atende o critério para 3FN é:
Venda
n_pedido #n_produto quant valor_unit subtotal
23560 0045 3 R$ 8,99 R$ 26,97
58741 1025 10 R$ 12,99 R$ 129,90
A tabela não está na Terceira Forma Normal porque a coluna subtotal é o resultado da
multiplicação quant X valor_unit, desta forma a coluna subtotal depende de outras colunas não-
chave. Para atender a Terceira Forma Normal, a tabela deve ser implementada da seguinte forma:
Venda
n_pedido #n_produto quant valor_unit
23560 0045 3 R$ 8,99
58741 1025 10 R$ 12,99
Note que a coluna subtotal foi eliminada da tabela, pois aplicando a 3FN, foi considerado
desnecessário armazenar esta informação no banco de dados.
2.4. Modelo Físico
Como vimos anteriormente, o Modelo Físico considera as limitações impostas pelo SGBD,
pois a transformação do Modelo Lógico no Modelo Físico consiste na implementação das tabelas
no SGBD. Para isso, iremos utilizar o SGBD MySQL, que é o assunto da próxima Lição.

Aqui vimos como modelar dos dados, antes de criar o banco de dados no SGBD.

3. SGBD MySQL
Nesta lição veremos o que é o SGBD MySQL e como instalá-lo.
Bom estudo!
3.1. O que é o MySQL?

O MySQL é um dos mais populares SGBD. É desenvolvido, distribuído e tem suporte da
MySQL AB. A MySQL AB é uma empresa comercial, fundada pelos desenvolvedores do MySQL,
cujo negócio é fornecer serviços relacionados ao SGBD MySQL.
O MySQL é um SGBD Relacional. Um banco de dados relacional armazena dados em
tabelas separadas, ao invés de colocar todos os dados em um só local. Isso proporciona velocidade e
flexibilidade. A parte SQL do “MySQL” atenta pela “Structured Query Language - Linguagem
Estrutural de Consultas”. SQL é linguagem padrão mais comum usada para acessar banco de dados
e é definida pelo Padrão ANSI/ISO SQL. O padrão SQL está evoluindo desde 1986 e existem
diversas versões.
O MySQL é um software Open Source. Open Source significa que é possível para qualquer
um usar e modificar o programa. Qualquer pessoa pode fazer download do MySQL pela Internet e
usá-lo sem pagar nada. Quem quiser, pode estudar o código fonte e alterá-lo para adequá-lo às suas
necessidades. O MySQL usa a GPL (GNU General Public License – Licença Pública Geral GNU),
para definir o que pode-se e não pode fazer com o software em diferentes situações. Se não quiser
utilizar a GPL ou precisar embutir o MySQL em uma aplicação comercial, pode adquirir a versão
comercial licenciada pela MySQL AB.
3.2. As principais características do MySQL

A lista a seguir descreve algumas das características mais importantes do MySQL.
• Portável.
• Escrito em C e C++.
• Funciona em diversas plataformas.
• Funções SQL são implementadas por meio de uma biblioteca de classes altamente otimizada
e com o máximo de performance.

• O código do MySQL foi testado com Purify (um detector comercial de falhas de memória) e
também com o Valgrind, uma ferramenta GPL.
• Disponível como versão cliente/servidor ou embutida.
• Álias em tabelas e colunas são disponíveis como definidos no padrão SQL92.
• DELETE, INSERT e UPDATE retornam o número de linhas que foram alteradas (afetadas).
• O comando específico do MySQL, SHOW, pode ser usado para devolver informações sobre
bancos de dados, tabelas e índices.
• Pode-se misturar tabelas de bancos de dados diferentes na mesma pesquisa.
• Um sistema de privilégios e senhas que é muito flexível, seguro e que permite verificação
baseada em estações/máquinas. Senhas são seguras porque todo o tráfico de senhas é
criptografado quando for se conectar ao servidor.
• Lida com bancos de dados enormes. Há quem use o Servidor MySQL com bancos de dados
que contém 50.000.000 registros e usuários que o usam com 60.000 tabelas e
aproximadamente 5.000.000.000 de linhas.
• São permitidos até 32 índices por tabela. Cada índice pode ser composto de 1 a 16 colunas.
O tamanho máximo padrão do índice é de 500 bytes.
• Os clientes podem se conectar ao servidor MySQL usando sockets TCP/IP, em qualquer
plataforma.
• O servidor pode apresentar mensagem de erros aos clientes em várias línguas.
• Suporte total para vários conjuntos de caracteres, que incluem ISO-8859-1 (Latin1) e mais.
• Para obter ajuda no MySQL podem ser chamadas as opções --help ou -?.
3.3. Instalação do MySQL no Ubuntu

Confira o site oficial do MySQL (http://www.mysql.com/) para informações sobre a versão
atual e para instruções de download. Neste curso trabalharemos com o MySQL 5.5.
Para fazer a instalação do MySQL no Ubuntu vamos utilizar uma das ferramentas mais
eficientes para instalação, o APT (Advanced Packaging Tool).
A distribuição Ubuntu possui uma ferramenta chamada “apt” para instalar softwares. Essa
ferramenta é de grande importância durante o processo de instalação, pois ela gerencia todo o
processo. No diretório /etc/apt existe um arquivo chamado “sources.list” com a função de
armazenar os endereços dos repositórios com os pacotes de instalação.

Para verificar se os pacotes estão realmente a disposição, digite o seguinte comando no

Terminal:
aptcache search mysqlserver
A saída será semelhante a esta:

mysql-server - MySQL database server (metapackage depending on the latest version)
mysql-server-5.5 - MySQL database server binaries and system database setup
mysql-server-core-5.5 - MySQL database server binaries
A última versão do MySQL-Server, neste exemplo, é a 5.5 . Agora para instalar basta digitar,
no Terminal, o comando:
aptget install mysqlserver
Será solicitada a confirmação da instalação, digite a letra “S”.

Durante a instalação, será solicitado que seja informada uma senha do usuário
Administrador do MySQL. Coloque uma senha segura e guarde-a. Esta senha será utilizada para
autenticação do usuário Administrador do MySQL.
Após a instalação, verifique o status do serviço MySQL, digitando o comando:
service mysql status
Se a saída for:
mysql start/running, process
O serviço está rodando corretamente. Caso contrário, digite:

service mysql start
3.4. Conectando o MySQL

Para conectar ao servidor MySQL, é preciso informar o nome do usuário do MySQL e uma
senha. Digite, no Terminal do Linux, o comando a seguir:
mysql u usuario p
Enter password: digite a senha cadastrada na instalação do MySQL
Sendo que o parâmetro:

-u indica que a próxima informação será o nome do usuário.

-p indica que é necessário que o usuário informe a senha de acesso ao Servidor MySQL
para efetuar a autenticação (altamente recomendado).
Se o servidor MySQL não estiver rodando na própria máquina, será necessário também
especificar um nome do servidor MySQL (hostname).
Neste caso, digite no Terminal o seguinte comando:
mysql h hostname u usuario p
Enter password: digite a senha cadastrada na instalação do MySQL
Sendo que o parâmetro -h indica que a próxima informação será o nome do computador
onde está instalado o Servidor MySQL.
No exemplo a seguir está uma forma de conexão com o MySQL.
mysql u root p
Enter password: ********
A conexão está sendo feita com o usuário root (Administrador) do MySQL, pois ainda não
existem outros usuários cadastrados.
Ao conectar no Servidor MySQL, o prompt ficará como mostrado a seguir. É nele que serão
digitados os comandos SQL.
mysql>
Para desconectar do Servidor MySQL, utilize o comando mostrado a seguir.

mysql> exit
Pode-se utilizar também o comando quit, ou ainda as teclas de atalho Ctrl + D.
No decorrer do curso veremos mais sobre o MySQL. Sua documentação completa, em

inglês, pode ser acessada no endereço http://dev.mysql.com/doc/refman/5.5/en/index.html.
3.5. Prompt do MySQL

Os comandos SQL podem ser digitados no prompt do MySQL. Um comando escrito todo
em uma única linha, assim como comandos compridos que requerem várias linhas, são aceitos pelo
MySQL. O MySQL determina que o comando termina por um ponto e vírgula e não, pelo fim de
uma linha de entrada.

A seguir um exemplo de um simples comando de linha múltipla:

mysql> SELECT
> USER()
> ,
> CURDATE() ;
mysql>
Neste exemplo, note como o prompt muda de mysql> para -> depois de entrar com a
primeira linha de uma linha múltipla. Assim, o MySQL está indicando que o comando não está
finalizado e aguarda o complemento.
A tabela a seguir mostra os prompt que podem aparecer e resume o estado do MySQL:
Prompt Significado
mysql> Pronto para um novo comando. Este é o prompt que deve estar aparecendo
sempre que for digitar um novo comando.
> Esperando a próxima linha do comando ou o ponto e virgula para execução do
comando. Para cancelar o comando e sair deste prompt, digite \c
'> Esperando a próxima linha, aguardando uma aspa simples. Isto ocorre quando é
aberta uma aspa simples e esta não é fechada. Para sair deste prompt, digite '\c
"> Esperando próxima linha, aguardando uma aspa dupla. Isto ocorre quando é
aberta uma aspa dupla e esta não é fechada. Para sair deste prompt, digite "\c
Utilize as Setas para cima e para baixo do teclado para repetir os comandos digitados. As setas
para direta e para esquerda permitem percorrer pela linha digitada.
Agora que instalamos e sabemos como conectar ao Servidor MySQL, finalmente poderemos
utilizá-lo! Para isso, nosso próximo passo será vermos como utilizar os comandos SQL para criar,
alterar e excluir tabelas, bem como inserir, modificar, selecionar e excluir os dados das tabelas. Este
será o assunto da próxima Lição!

Aqui vimos o que é o MySQL, como instalá-lo no Ubuntu e como entrar e sair dele.

4. Comandos SQL
Nesta lição veremos os principais comandos SQL (Structured Query Language, ou
Linguagem de Consulta Estruturadas).
Bom estudo!
4.1. Introdução
O SQL (Structured Query Language, ou Linguagem de Consulta Estruturadas) é uma
linguagem que tornou-se um padrão na indústria para Bancos de Dados Relacionais. Ela é bem
diferente das linguagens comuns de programação.
A principal diferença é que o SQL não é uma linguagem procedural, ao contrário da grande
maioria das linguagens de programação. Nela não se especifica como, ou em que ordem, serão
executados os processos que irão fornecer os resultados requeridos.
No SQL, apenas informa-se o que se quer e o sistema de banco de dados é o responsável por
escolher adequadamente os procedimentos a serem executados, de forma que os resultados sejam
obtidos com a maior eficiência possível.
Apesar do SQL ter sido originalmente criado pela IBM, rapidamente surgiram vários
“dialetos” desenvolvidos por outros produtores. A expansão levou à necessidade de ser criado e
adaptado um padrão para a linguagem.
Esta tarefa foi realizada pela American National Standards Institute (ANSI) em 1986 e ISO
(International Organization for Standardization) em 1987, os quais formaram um grupo de trabalho
para continuar o desenvolvimento. Este desenvolvimento ainda acontece com outras novas versões
dos padrões definidos.
Embora padronizado pela ANSI e ISO, o SQL possui muitas variações e extensões
produzidas pelos diferentes fabricantes de SGBD. Normalmente, a linguagem pode ser migrada de
plataforma para plataforma sem mudanças estruturais.

4.2. Tipos de Comandos
Na linguagem SQL existem três tipos de comandos:

• DDL (Data Definition Language - Linguagem de Definição de Dados): permite ao
usuário definir tabelas novas e elementos associados. Os comandos básicos da DDL são:
• CREATE: usado para criar um objeto (por exemplo, banco de dados e tabelas).
• DROP: usado para apagar um objeto do banco de dados.
• ALTER: usado para alterar um objeto (por exemplo, adicionar uma coluna a uma tabela).
• DML (Data Manipulation Language - Linguagem de Manipulação de Dados): permite

ao usuário selecionar, inserir, atualizar e apagar dados. Os comandos básicos da DML são:
• INSERT: usado para incluir dados em uma tabela.
• UPDATE: usado para alterar os valores de dados em uma ou mais linhas de uma tabela.
• DELETE: usado para remover uma ou mais linhas de uma tabela.
• SELECT: usado para consultar os dados das tabelas.
• DCL (Data Control Language - Linguagem de Controle de Dados): define os aspectos de

autorização de dados e licenças de usuários para controlar quem tem acesso para ver ou
manipular dados dentro do banco de dados. Os comandos básicos da DCL são:
• GRANT: usado para autorizar ao usuário executar ou setar operações.
• REVOKE: usado para remover ou restringir as capacidade dos usuários de executar
operações.
Vale ressaltar que todos os comandos SQL devem ser executados dentro do prompt do
MySQL, ou seja, é preciso executar o comando visto na Lição 3.4. Conectando o MySQL.
Outro detalhe sobre os comandos SQL, é que o comando não é executado pressionando a
tecla ENTER, como os comandos executados no prompt do sistema operacional. Para executar o
comando SQL no prompt do MySQL, é preciso finalizá-lo com o caractere “ ; ”. Com este caractere
o MySQL compreende que o comando precisa ser executado após pressionada a tecla ENTER.
Caso não seja colocado o “ ; ”, o MySQL apenas abrirá uma nova linha no comando SQL.

4.3. DDL - Linguagem de Definição de Dados
Como vimos anteriormente, os principais comandos DDL são: CREATE, DROP e ALTER.
Vamos ver cada um deles.
4.3.1. Criando um Banco de Dados

Estando conectado ao MySQL, pode-se utilizar um banco de dados existente ou criar um
novo. Vamos ver a sintaxe do comando para criar um novo banco de dados:
mysql> CREATE DATABASE nome_do_banco_de_dados;
Para criar o banco de dados chamado curso, execute o comando:

mysql> CREATE DATABASE curso;
Os nomes de bancos de dados são case sensitive (ao contrário das palavras reservados do SQL).
Portanto, deve-se sempre fazer referência ao banco de dados, neste exemplo, como curso e não
Curso ou outra variação. Isto também vale para nomes de tabelas e das colunas.
4.3.1.1. Verificando os Bancos de Dados Existentes

Para verificar os bancos de dados que existem no MySQL, execute o comando:
mysql> SHOW DATABASES;
O resultado será semelhante ao mostrado a seguir:

++
| Database |
++
| curso |
| information_schema |
| mysql |
| performance_schema |
| test |
++
7 rows in set (0.13 sec)
Na lista aparece o banco de dados que acabamos de criar: curso. Os outros bancos de dados
são criados durante a instalação do MySQL e são usados pelo sistema para seu funcionamento. O
banco de dados mysql é necessário porque ele descreve privilégios de acessos de usuários. O banco
de dados test é geralmente fornecido como um espaço para que o usuário possa fazer testes.

4.3.1.2. Selecionando um Banco de Dados

Como pode-se observar, o MySQL possui vários bancos de dados. Portanto, deve-se sempre
informar ao MySQL qual banco de dados deseja-se utilizar. Para selecionar o banco de dados curso,
execute o comando:
mysql> USE curso
Se o comando foi executado corretamente, aparecerá a mensagem: Database changed.
Note que no comando USE não foi preciso utilizar “ ; ” no final, embora na maioria dos
comandos, o uso seja obrigatório para a sua execução.
O banco de dados necessita ser criado somente uma vez, mas deve-se selecioná-lo para o
uso toda vez que entrar no MySQL.
Uma forma alternativa é selecionar o banco de dados na linha de comando quando inicia o
MySQL. Para isso, especifique o nome do banco depois de qualquer parâmetro de conexão que
deve ser fornecido. Por exemplo:
mysql u root p curso
Enter password:
Note que curso não é a senha de acesso e sim o nome do banco de dados a ser usado.
Para saber qual banco de dados está selecionado, execute o comando:

mysql> SELECT DATABASE();
4.3.2. Excluindo um Banco de Dados

A sintaxe do comando para excluir um banco de dados é:
mysql> DROP DATABASE nome_do_banco_de_dados;
A execução deste comando exclui todas as tabelas e os dados armazenados no banco de

dados especificado. Este comando deve ser executado com cuidado, pois não emite nenhuma
mensagem de alerta antes da execução.

4.3.3. Criando Tabelas

Depois de selecionar o banco de dados (no nosso exemplo, curso) pode-se iniciar a criação
das tabelas. A sintaxe para criar uma tabela é:
mysql> CREATE TABLE nome_da_tabela(
> nome_da_coluna tipo_de_dado [NOT NULL]|[NOT NULL WITH DEFAULT]
> [ PRIMARY KEY (nome_coluna_chave) , ]
> [ CONSTRAINT nome_ChEs FOREIGN KEY (nome_coluna_ChEs)
REFERENCES nome_Tabela_Pai (nome_coluna_TP)
ON DELETE [RESTRICT][CASCADE][SET NULL]
ON UPDATE [RESTRICT][CASCADE][SET NULL] , ]
> [ UNIQUE nome_indice_unico (nome_da_coluna), ]
> [ INDEX nome_indice_nao_unico (nome_da_coluna) ]
> )
> [ ENGINE = tipo_da_tabela ] ;
O nome que o usuário define aos objetos dentro do MySQL, incluindo banco de dados,
tabela, coluna, índice, aliás e outros, são conhecidos como identificadores. Com relação a estes
identificadores, algumas regras devem ser observadas:
• Podem conter letras, dígitos, cifra e sublinhado;
• Podem começar com um dígito, mas não pode ter somente dígitos;
• Não podem terminar com caracteres de espaço;
• Não podem utilizar palavras reservadas do MySQL (Exemplo: nome de comados e funções,
como: table, database, create, insert, delete, where, count, max, etc.).
• Não é recomendado a utilização da caracteres especiais.
• É feita a distinção entre caracteres maiúsculos e minúsculos (case sensitive).
4.3.3.1. Tipos de Dados

Como vimos na sintaxe do comando CREATE TABLE, precisamos definir para cada coluna
(campo) de uma tabela um tipo de dado que determinará as informações que serão armazenadas. Os
tipos de dados de uma coluna são divididos em três grupos: Numérico, Data e Cadeia.
• Tipo Numérico: podem ser divididos em dois grandes grupos: os números inteiros e os
números reais.

Tipos de Dados Numéricos

Tipo Tamanho ocupado Limites e descrição
TinyInt (limite) 1 byte Números inteiros de -128 até 127
(ou sem sinal, de 0 até 255)
SmallInt (limite) 2 bytes Números inteiros de -32768 até 32767 (ou sem
sinal, de 0 até 65535)
MediumInt (limite) 3 bytes Números inteiros de -8.388.608 até 8.388.607
(ou sem sinal, de 0 até 16777215
Integer, Int (limite) 4 bytes Números inteiros de -2147483648 até
2147483647 (ou sem sinal, de 0 até
429.496.295
BigInt (limite) 8 bytes Números inteiros de
-9.223.372.036.854.775.808 até
9.223.372.036.854.775.807 (ou sem sinal, de 0
até 18.446.744.073.709.551.615
Float 4 bytes Número grande com ponto de decimais
flutuante (precisão até 8 casas)
Double (limite, decimais) 8 bytes Número grande com ponto de decimais
flutuante (precisão até 16 casas)
Decimal (limite, decimais) Valor inserido + 1 Número em vírgula flutuante desempacotado. O
ou 2 bytes número armazena-se como uma cadeia.
• Tipo de data: usado para armazenar datas, o MySQL não verifica de uma maneira restrita
se uma data é válida ou não. Simplesmente comprova que o mês está compreendido entre 0
e 12 e que o dia está compreendido entre 0 e 31.
Tipos de Dados de Data
Date 8 bytes Data, de 01/01/1001 a 31/12/9999.
O formato é YYYY-MM-DD
DateTime 8 bytes Data e hora, de 01/01/1001 às 00:00:00 a
31/12/9999 às 23:59:59.
O formato é de YYYY-MM-DD HH:MM:SS
TimeStamp 4 bytes Data e hora, de 01/01/1970 ao ano 2037. O
formato é YYYYMMDDHHMMSS
Time 3 bytes Hora, de -838 horas, 59 minutos e 59 segundos.
O formato HH:MM:SS
Year 1 byte Ano, de o ano 1901 ao ano 2155.
O formato é YY ou YYYY

• Tipo de cadeia: este tipo engloba os valores alfanuméricos.
Tipos de Dados de Cadeia

Char (limite) Tamanho definido Texto de tamanho fixo, de 0 até 255
caracteres
VarChar (limite) Texto inserido + 1 byte Texto de tamanho variável, de 0 até 255
caracteres
TinyText Texto inserido + 1 byte Texto com até 255 caracteres
Text Texto inserido + 2 bytes Texto com até 65.535 caracteres.
MediumText Texto inserido + 3 bytes Texto com até 16.777.215 caracteres.
LongText Texto inserido + 4 bytes Texto com até 4.294.967.295 caracteres.
(É importante levar em conta que nos
protocolos de comunicação os pacotes
podem ter um máximo de 16 Mb.
Enum 1 ou 2 bytes Cada registro pode conter um valor da lista.
Aceita até 65.535 valores diferentes.
Set Cada registro pode conter um, vários ou
nenhum valor da lista.
Aceita até 64 valores.
4.3.3.2. Tipos de Tabela

Como vimos na sintaxe do comando CREATE TABLE, podemos definir também o Tipo de
Tabela no momento da sua criação. O formato de armazenamento dos dados, bem como alguns
recursos do banco de dados são dependentes do tipo de tabela escolhido. Por isso, é importante
analisar qual dos diferentes tipos de tabela suportados pelo MySQL, atende melhor a necessidade de
armazenamento.
O MySQL suporta dois tipos diferentes de tabelas:
1. Tabelas Seguras com Transação (TST): um dos principais mecanismos de armazenamento
dessas tabelas é o InnoDB.
◦ InnoDB: é um mecanismo de armazenamento seguro com transações (compatível com
ACID) com commit, rollback, e recuperação em caso de falhas. Para manter a
integridade referencial dos dados, o InnoDB também suporta chaves estrangeiras
(Foreign Key) mantendo as restrições referenciadas nos dados armazenados. O InnoBD
é o motor de armazenamento padrão do MySQL a partir da versão "5.5.5" descrita na
documentação oficial.

2. Tabelas Não Seguras com Transação (TNST): um dos principais mecanismos de

armazenamento dessas tabelas é o MyISAM.
◦ MyISAM: é um dos mecanismos de armazenamento do MySQL mais utilizado na Web
e para armazenamento de dados históricos (data warehousing). O MyISAM é suportado
em todas as versões do MySQL sendo ele o motor de armazenamento padrão do MySQL
anterior a versão "5.5.5" descrita na documentação oficial.
As vantagens de Tabelas Seguras com Transação (TST) são:

• Mais segura. Mesmo se o MySQL falhar ou se tiver problemas com hardware, pode-se ter
os dados de volta, ou através de recuperação automática ou de um backup + o log de
transação.
• Pode-se combinar muitas instruções e aceitar todas de uma vez com o comando COMMIT.
• Pode-se executar um ROLLBACK para ignorar suas mudanças (se não estiver rodando em
modo auto-commit).
• Se uma atualização falhar, todas as suas mudanças serão restauradas.
• Pode fornecer melhor concorrência se a tabela obter muitas atualizações concorrentes com
leituras.
As vantagens de Tabelas Não Seguras com Transação (NTST) são:

• Muito mais rápida e não há nenhuma sobrecarga de transação.
• Usará menos espaço em disco já que não há nenhuma sobrecarga de transação.
• Usará menos memória para as atualizações.
4.3.3.3. Chave Primária e Estrangeira

No Modelo Lógico vimos que existem as Chaves Primárias e Chaves Estrangeiras. Para a
criação desse tipo de estrutura no Modelo Físico é importante entendermos como elas funcionam:
• Chave Primária (ou Primary Key): é uma coluna da tabela com valores únicos que
caracterizam os registros. Por exemplo, a tabela departamento tem as colunas cod_dep e
nome. A coluna cod_dep nesta tabela representa a Primary Key desta tabela, pois seus
valores devem ser únicos e identificam individualmente cada registros. Da mesma forma
que a coluna cod_emp é a Primary Key da tabela empregado.

• Chave Estrangeira (ou Foreign Key): é a chave primária de outra tabela que servirá como
elo entre elas. Por exemplo, a coluna dep_id da tabela empregado é a Foreign Key d a
coluna cod_dep da tabela departamento, que por sua vez, é a chave primaria desta tabela.
Para trabalhar com integridade referencial, isto é, para adicionarmos restrições de
integridade (constraints) às chaves estrangeiras, é necessário criar as tabelas como InnoDB. O
InnoDB implementa as restrições de integridade de três formas distintas:
• RESTRICT: se existir um registro filho com diversos registros pais, não é permitido a
exclusão (DELETE) ou alteração (UPDATE) de qualquer um dos registros pais. Esta é a
forma padrão, assumida caso não seja definido nenhum parâmetro.
• CASCADE: se um registro na tabela pai for deletado (atualizado), o InnoDB
automaticamente também exclui (DELETE) ou altera (UPDATE) todos registros na tabela
filha cujos valores de chaves estrangeiras são iguais ao valor da chave referenciada no
registro pai.
• SET NULL: os registros filhos são automaticamente excluídos (DELETE) ou atualizados
(UPDATE) e assim as colunas na chave estrangeira são definidas com o valor NULL.
A criação das tabelas departamento e empregado, mostradas a seguir, ilustram como definir
as restrições de integridade e também a criação de índices.
Não é possível criar a tabela empregado antes da tabela departamento. Isso acontece porque
ainda não podemos relacionar a chave primaria da tabela departamento com a chave
estrangeira da tabela empregado, sendo possível após a criação da tabela departamento.
Portanto, vamos primeiro criar a tabela departamento. Para isso, execute o comando:
mysql> CREATE TABLE departamento(
> cod_dep SMALLINT,
> nome VARCHAR(30) NOT NULL,
> PRIMARY KEY (cod_dep),
> UNIQUE uk_nome_dep (nome) );
Observa-se que a sintaxe do CREATE TABLE é muito simples, sendo necessário apenas
informar o nome da tabela, no caso departamento, as colunas da tabela, os tipos de dados e o tipo
da tabela, podendo este último ser ocultado se for do tipo InnoDB.

Neste exemplo, definimos para a tabela departamento as colunas cod_dep e nome, e os,
respectivos, tipos de dados SMALLINT e VARCHAR(30).
Foi criado um Índice Único chamado uk_nome_dep para a coluna nome, pois esta coluna
pode ser bastante pesquisada e não pode ter valor repetido. É importante saber o nome deste índice
para poder apagá-lo posteriormente.
Agora sim, vamos criar a tabela empregado.
mysql> CREATE TABLE empregado(
> cod_emp INT,
> nome VARCHAR(90) not null,
> salario DECIMAL(10,2),
> data_admissao DATE,
> data_demissao DATE,
> dep_id SMALLINT,
> PRIMARY KEY (cod_emp),
> CONSTRAINT ches_emp FOREIGN KEY (dep_id) REFERENCES
departamento(cod_dep) ON DELETE RESTRICT ON UPDATE CASCADE ,
> INDEX in_nome_emp (nome),
> INDEX in_salario (salario) );
Foram criados dois Índices Não-Único: in_nome_emp, in_salario. O índice in_nome faz
referência ao nome do empregado, que costuma ser bastante consultado e que pode ter o valor
repetido, no caso de dois empregados com o mesmo nome. O índice in_salario faz referência ao
salário do empregado e também pode ter o valor repetido, no caso de empregados com o mesmo
valor de salário.
Note que as colunas cod_dep da tabela departamento e dep_id da tabela empregado
(chave estrangeira da primeira) armazenam dados do mesmo tipo: SMALLINT. Este é um dos pré-
requisitos para a implementação da chave estrangeira.
Para visualizar os nomes das tabelas existentes neste banco de dados, execute o comando:
mysql> SHOW TABLES ;
Para visualizar a estrutura da tabela departamento, execute o comando:

mysql> DESCRIBE departamento ;

Para visualizar a estrutura da tabela empregado com mais detalhes, inclusive com os nomes
dos índices/chaves, execute o comando:
mysql> SHOW CREATE TABLE empregado \G
Às vezes, podem aparecer avisos (warning) durante a execução dos comandos no MySQL.
Para visualizar informações sobre estes avisos, execute o comando:
mysql> \W
No MySQL, ao criar uma tabela pode-se utilizar a expressão AUTO_INCREMENT para

atribuir valores automaticamente à coluna da tabela assim definida. Por exemplo:
mysql> CREATE TABLE animal (
> cod_animal INT AUTO_INCREMENT,
> nome VARCHAR(20),
> dono VARCHAR(20),
> especie VARCHAR(20),
> sexo CHAR(1),
> aniversario DATE,
> morte DATE,
> PRIMARY KEY(cod_animal));
No esquema acima, foi criada a tabela animal, com a coluna cod_animal, definido como
AUTO_INCREMENT. Note que não é possível utilizar a palavra AUTO_INCREMENT sem
informar que a coluna é PRIMARY KEY. Esta coluna receberá valores automaticamente, sendo
necessário informar apenas a palavra default quando utilizada a instrução INSERT:
mysql> INSERT INTO animal VALUES (default, 'nome_do_animal',
'dono', 'especie', 'm', '2000/02/01', NULL);
Desta forma, toda vez que for inserido um novo registro, o valor da coluna cod_animal
será incrementado automaticamente.
Vamos praticar!
Exercício 1) Criar uma tabela chamada teste, com duas colunas: codigo do tipo INT e nome do
tipo CHAR(20). A coluna codigo é chave primária e a nome é um índice não-único.
Exercício 2) Visualizar as tabelas do banco de dados curso.
Exercício 3) Visualizar a estrutura da tabela teste.

4.3.4. Alterando a estrutura da tabela

O comando para alterar a estrutura de uma tabela é o ALTER TABLE. Com ele é possível
alterar a estrutura de uma tabela acrescentando, alterando e retirando nomes, formatos das colunas e
a integridade referencial definidas em uma determinada tabela.
A sintaxe para alterar o nome de uma tabela é:
mysql> ALTER TABLE nome_da_tabela RENAME TO novo_nome_da_tabela;
A sintaxe para incluir uma coluna de uma tabela é:

mysql> ALTER TABLE nome_da_tabela ADD nome_da_nova_coluna
tipo_de_dado [NOT NULL] [NOT NULL WITH DEFAULT] ;
A sintaxe para excluir uma coluna de uma tabela é:

mysql> ALTER TABLE nome_da_tabela DROP nome_da_coluna;
A sintaxe para alterar o nome de uma coluna de uma tabela é:

mysql> ALTER TABLE nome_da_tabela CHANGE nome_da_coluna
novo_nome_da_coluna [ novo_tipo_de_dado ];
A sintaxe para alterar o tipo de uma coluna de uma tabela é:

mysql> ALTER TABLE nome_da_tabela MODIFY nome_da_coluna
tipo_de_dado [NULL] [NOT NULL] [NOT NULL WITH DEFAULT] ;
A sintaxe para adicionar uma chave primária em uma tabela é:

mysql> ALTER TABLE nome_da_tabela ADD PRIMARY KEY nome_da_coluna;
A sintaxe para excluir uma chave primária em uma tabela é:

mysql> ALTER TABLE nome_da_tabela DROP PRIMARY KEY ;
A sintaxe para adicionar uma chave estrangeira em uma tabela é:

mysql> ALTER TABLE nome_da_tabela ADD FOREIGN KEY
(nome_coluna_chave_estrangeira) REFERENCES (nome_tabela_pai)
[ ON DELETE [RESTRICT] [CASCADE] [SET NULL] ]
[ ON UPDATE [RESTRICT] [CASCADE] [SET NULL] ] ;

A sintaxe para excluir uma chave estrangeira em uma tabela é:

mysql> ALTER TABLE nome_da_tabela DROP FOREIGN KEY
(nome_coluna_chave_estrangeira) REFERENCES (nome_tabela_pai) ;
A sintaxe para adicionar um índice único em uma tabela é:

mysql> ALTER TABLE nome_da_tabela ADD UNIQUE nome_do_indice
(nome_da_coluna) ;
A sintaxe para adicionar um índice não único em uma tabela é:

mysql> ALTER TABLE nome_da_tabela ADD INDEX nome_do_indice
(nome_da_coluna) ;
A sintaxe para excluir um índice único ou não único em uma tabela é:

mysql> ALTER TABLE nome_da_tabela DROP INDEX nome_da_indice ;
4.3.5. Excluindo a tabela

A sintaxe para excluir a estrutura de uma tabela é:
mysql> DROP TABLE nome_da_tabela;
Vamos praticar!
Exercício 1) Alterar o nome da tabela teste para cadastro.

Exercício 2) Alterar a tabela cadastro, adicionando uma nova coluna chamada endereco do tipo
VARCHAR(50).
Exercício 3) Modificar o tipo da coluna nome da tabela cadastro para CHAR(50).
Exercício 4) Modificar o nome da coluna endereco da tabela cadastro para endereco_residencial
do tipo VARCHAR(70).
Exercício 5) Apagar a coluna endereco_residencial da tabela cadastro.
Exercício 6) Alterar a tabela cadastro, apagando a chave primária da coluna codigo (sem apagar a
coluna).
Exercício 7) Apagar toda a estrutura da tabela cadastro.

4.4. DML - Linguagem de Manipulação de Dados
Os principais comandos DML são: INSERT, SELECT, UPDATE e DELETE. Vamos ver
cada um deles.
4.4.1. Inserindo dados na tabela

A sintaxe do comando para inserir dados na tabela é:
mysql> INSERT INTO nome_da_tabela [(nome_da_coluna1,
nome_da_coluna2, ...) ] VALUES (relação dos valores a serem
incluídos);
No comando INSERT, os valores são passados para cada coluna, na ordem em que as
colunas foram listadas na instrução CREATE TABLE. Neste caso, para inserir os dados na tabela
departamento, pode-se executar o comando:
mysql> INSERT INTO departamento VALUES (10,'Vendas'),
(20,'Recursos Humanos'), (30,'Transporte');
O comando a seguir também está correto:

mysql> INSERT INTO departamento (cod_dep, nome) VALUES
(40,'Suporte');
Para inserir dados na tabela empregado, execute o comando:

mysql> INSERT INTO empregado (cod_emp, nome, salario,
data_admissao, data_demissao, dep_id) VALUES
> (100,'Joaquim Ribas', '6000.30', '2000/01/12', '', 10),
> (105,'Euzébio Peixoto', '3800.00', '2000/03/03', '', 10),
> (106,'Lara Nunes', '2200.15','2000/05/03', '2013/10/20', 20),
> (107,'Pilar Souza', '3200.45','2003/07/03', '2012/09/20', 10);
Como todas as colunas estão recebendo dados na ordem em que foram criados na tabela,
pode-se executar o comando simplificado:
mysql> INSERT INTO empregado VALUES
> (109,'Alessandro Barbosa', '2344.50' ,'2010/12/01', '', 30);

Se a tabela for criada com uma coluna com AUTO_INCREMENT, no caso o cod_aninal da
tabela animal, pode-se executar o comando SQL:
mysql> INSERT INTO animal (nome, dono, especie, sexo,
aniversario, morte) VALUES
> ('Lulu','João Paulo Oliveira','Cão','M','20000201', NULL);
Desta forma, toda vez que for inserido um novo registro, o valor da coluna cod_animal será
incrementado automaticamente.
Com relação ao dados que são inseridos nas colunas, deve-se observar que:
1) Os números decimais devem ser indicados com ponto (.) e não com vírgula (,).
2) Os dados com caracteres e datas são especificados com aspas.
3) As datas devem ser armazenadas no formato AAAA/MM/DD.
Vamos praticar!
Exercício 1) Inserir os dados a seguir na tabela empregado:

cod_emp nome salario data_admissao data_demissao dep_id
120 Mateus Pereira R$ 3000 2009/06/10 2013/12/15 30

125 João Xavier R$ 2200 2009/09/01 2013/12/15 40
142 Carla Almeida R$ 2500 2010/10/10 - 40
143 Paula Fonseca R$ 2500 2010/11/10 - 30
145 Antônio Castilhos R$ 2500 2010/04/10 - 20
Exercício 2) Inserir os dados a seguir na tabela departamento:

cod_dep nome
45 Seção de Informática
50 Atendimento ao Cliente

4.4.2. Selecionando dados na tabela

A sintaxe do comando para selecionar os dados inseridos em uma tabela é:
mysql> SELECT nome_da_coluna [, nome_da_coluna]
FROM nome_da_tabela [, nome_da_tabela]
[ WHERE condição ]
[ GROUP BY nome_da_coluna [HAVING <condição> ] ]
[ ORDER BY nome_da_coluna [ ASC | DESC ] ] ;
Para selecionar todos os dados da tabela departamento, execute o comando:

mysql> SELECT * FROM departamento;
Para selecionar apenas o nome dos departamentos, execute o comando:

mysql> SELECT nome FROM departamento;
Para selecionar o nome e salário dos empregados, execute o comando:

mysql> SELECT nome, salario FROM empregado;
4.4.2.1. Parâmetro WHERE

O parâmetro WHERE é um argumento opcional do comando SELECT (UPDATE e
DELETE, que serão vistos adiante). Seu objetivo é filtrar o conjunto de resultados para que somente
os registros que atendam a determinadas condições sejam visualizados.
Geralmente as condições de uma expressão que utiliza WHERE testam uma comparação de
valores entre uma coluna da tabela e um valor predeterminado ou até de outra tabela.
A sintaxe do comando SQL com o parâmetro WHERE é:
[ WHERE condição ] ;
Por exemplo, para selecionar o nome e salario dos empregados do departamento 10

(dep_id=10), execute o comando:
mysql> SELECT nome, salario FROM empregado WHERE dep_id = 10;

Para selecionar o nome e salário dos empregados do departamento 10 (dep_id = 10) e com
salário maior que 2000, execute o comando:
mysql> SELECT nome, salario FROM empregado
> WHERE dep_id = 10 AND salario > 2000;
Existem vários operadores que podem ser utilizados na condição WHERE:

Operador Descrição
'= Igual
<> ou != Diferente de
< Menor que
> Maior que
<= Menor ou Igual que
>= Maior ou Igual que
OR Testa duas condições, sendo necessário apenas uma ser satisfeita
AND Testa duas condições, sendo necessário todas serem satisfeitas
BETWEEN … AND ... Verifica se um valor está dentro de uma faixa de valores.
NOT BETWEEN … AND ... Verifica se um valor NÃO está dentro de uma faixa de valores.
LIKE Verifica se os valores se encaixam no padrão informado.
NOT LIKE Verifica se os valores NÃO se encaixam no padrão informado.
IS Compara com um valor booleano (verdadeiro ou falso).
IS NOT Compara com um valor booleano (verdadeiro ou falso) negando-o.
IS NULL Testa se o valor é nulo (NULL).
IS NOT NULL Testa se o valor é diferente de nulo (NULL).
Vamos praticar!
Exercício 1) Selecionar o nome do departamento com código 10.

Exercício 2) Selecionar os empregados que têm salário maior que R$ 5.000,00.
Exercício 3) Selecionar o nome do empregado com código maior que 100.
Exercício 4) Selecionar nome e salário do empregado com cod_emp igual a 106.
Exercício 5) Selecionar os empregados que não sejam do departamento 10.
Exercício 6) Selecionar o nome dos departamentos que não tenham o código 20.
Exercício 7) Selecionar todos dados dos empregados que recebam salário maior ou igual a R$
3.000,00.

Exercício 8) Selecionar todos dados dos empregados que recebem salário entre R$ 3.000,00 e R$
5.000,00.
SELECT * FROM empregado WHERE salario BETWEEN 3000 AND 5000;
Exercício 9) Selecionar o codigo, nome e salario dos dos empregados com código entre 100 e 106.
Exercício 10) Selecione todos dados dos departamentos com código entre 1 e 50.
Exercício 11) Selecionar todos dados dos empregados cujo nome começam com a letra “A”.
SELECT * FROM empregado WHERE nome LIKE 'A%';
O parâmetro LIKE permite o uso do caractere “ % ”, que funciona como coringa. Neste
caso, a condição indica que a palavra precisa iniciar com a letra A e o que vem depois não é
relevante. O coringa pode ser usado também como terminador ou para indicar a presença do
caractere A, por exemplo, independente da sua posição (%A%).
Exercício 12) Selecionar nome e salario dos empregados cujo nome terminam com a letra “o”.
Exercício 13) Selecionar todos dados dos departamentos que tenham as letras “nd” no nome.
Exercício 14) Selecionar todos dados dos empregados que tenham a letra “A” no nome e salário
maior que 2.400.
Exercício 15) Selecionar todos dados dos empregados que trabalham no departamento 10 ou que
estão recebendo um salário maior que 2.300,00.
4.4.2.2. Funções com Datas

O MySQL fornece várias funções que podem ser utilizadas para realizar cálculos em datas,
por exemplo, para calcular idades ou extrair partes de datas.
O comando SQL para mostrar a versão instalada do MySQL e a data corrente é:
mysql> SELECT VERSION(), CURDATE() ;
Por exemplo, para determinar quantos anos cada empregado trabalha na empresa, calcule a
diferença de anos da data atual e da data de admissão. Depois subtraia se o dia/mês da data atual for
anterior ao dia/mês da data de admissão. A consulta a seguir, mostra, para cada empregado não
demitido, a data de admissão, a data atual e a tempo de serviço em anos.
mysql> SELECT nome, data_admissao, data_demissao, CURDATE(),
( YEAR(CURDATE()) YEAR(data_admissao) )
( RIGHT(CURDATE(),5) < RIGHT(data_admissao,5) ) AS Tempo
> FROM empregado WHERE data_demissao = '0000/00/00' ;

A função YEAR() separa a parte do ano de uma data e RIGHT() separa os cinco caracteres
mais a direita que representam a parte da data MM-DD. A expressão completa é um tanto
deselegante, então um apelido (AS Tempo) é usado para exibir uma saída mais apresentável para o
usuário.
Outra consulta pode ser usada para determinar, para os empregados demitidos, quantos anos
de serviço eles tinham quando foram demitidos.
Para determinar quais são os empregados demitidos, confira se data_demissão não é vazia
(data_demissao != '0000/00/00'). Depois, para estes, calcule a diferença entre os valores das colunas
data_demissao e data_admissao:
mysql> SELECT nome, data_admissao, data_demissao,
( YEAR(data_demissao) YEAR(data_admissao) )
( RIGHT(data_demissao,5) < RIGHT(data_admissao,5) )
AS 'Tempo de Serviço'
> FROM empregado WHERE data_demissao != '0000/00/00'
> ORDER BY 'Tempo de Serviço';
Para saber quais empregados completam aniversário de admissão no próximo mês, não é
preciso conhecer o ano e o dia. Pode-se extrair a parte do mês da coluna data_admissao.
O MySQL fornece diversas funções para extrair partes da data, como em YEAR(),
MONTH() e DAYOFMONTH().
MONTH é a função apropriada aqui. Para ver como ela funciona, execute uma consulta que
mostra o mês da admissão dos empregados:
mysql> SELECT nome, data_admissao, MONTH(data_admissao)
FROM empregado ;
Encontrar empregados com aniversário de tempo de serviço no próximo mês também é fácil.
Suponha que o mês atual é abril. Então o valor do mês é 4 e procura-se por empregados admitidos
em Maio (mês 5) assim:
mysql> SELECT nome, data_admissao
> FROM empregado
> WHERE MONTH(data_admissao) = 5 ;

Pode-se também escrever uma consulta para que funcione independente do mês atual.
Assim não precisa usar um número de mês em particular na consulta. A função DATE_ADD()
permite adicionar um intervalo de tempo para uma data fornecida. Se adicionar um mês para o valor
de CURDATE e então extrair a parte do mês com MONTH(), o resultado é o mês no qual estamos
procurando pelos admitidos:
> FROM empregado
> WHERE MONTH(data_admissao) =
> MONTH( DATE_ADD(CURDATE(), INTERVAL 1 MONTH) ) ;
Outra maneira para realizar a mesma tarefa é adicionar 1 para obter o mês seguinte ao atual:
> FROM empregado
> WHERE MONTH(data_admissao) = MOD( MONTH(CURDATE()), 12 ) + 1 ;
Perceba que MONTH retorna um número entre 1 e 12 e MOD(alguma_coisa,12) retorna um

número entre 0 e 11. Então a adição (+1) tem que ser feita depois do MOD(), caso contrário, corria-
se o risco de ir de Novembro (11) para Janeiro (1).
Para formatar a data (dia/mês/ano), pode-se utilizar a função:

DATE_FORMAT(data, '%d/%m/%Y').
mysql> SELECT nome, DATE_FORMAT(data_admissao, '%d/%m/%Y') AS
Data
FROM empregado;
Vamos praticar!
Exercício 1) Selecionar todos dados dos empregados cuja data de admissão seja no ano 2000.
Exercício 2) Selecionar todos dados dos empregados com data de admissão no ano 2000 e código
maior que 100.
Exercício 3) Selecionar todos dados dos empregados com data de admissão no ano 2000 ou
código maior que 106.

4.4.2.3. Funções Matemáticas do MySQL

Além das operações e parâmetros vistos anteriormente, algumas funções do SQL podem ser
utilizadas para otimizar o resultado de operações, como a soma de valores e o cálculo de média,
entre outras operações que serão abordadas a seguir.
Função DISTINCT
A função DISTINCT pode ser utilizada para evitar que valores repetidos sejam visualizados
em uma consulta.
A sintaxe do comando SQL utilizando a função DISTINCT é:
mysql> SELECT DISTINCT(nome_da_coluna) FROM nome_da_tabela ;
Por exemplo, para selecionar os departamentos que têm empregados alocados (sem repetir
os códigos do departamento), utilize o comando SQL a seguir.
mysql> SELECT DISTINCT(dep_id) FROM empregado ;
Função COUNT
A função COUNT executa a contagem de registros de uma tabela.
A sintaxe do comando SQL utilizando a função COUNT é:
mysql> SELECT COUNT(nome_da_coluna) FROM nome_da_tabela
A função COUNT(*) conta o número de resultados NOT NULL, portanto a consulta SQL
para contar a quantidade de empregados cadastrados nesta tabela é:
mysql> SELECT COUNT(*) FROM empregado ;
É possível utilizar esse comando com o parâmetro WHERE para filtrar os registros. Por
exemplo, para contar quantos empregados recebem salário maior que R$ 3.000,00, o seguinte
comando SQL pode ser utilizado:
mysql> SELECT COUNT(*) FROM empregado WHERE salario > 3000 ;
Função SUM
A função SUM realiza a soma dos valores de uma coluna.
A sintaxe do comando SQL utilizando a função SUM é:

mysql> SELECT SUM(nome_da_coluna) FROM nome_da_tabela
Por exemplo, para somar o salário de todos os empregados cadastrados, utilize o seguinte
comando SQL.
mysql> SELECT SUM(salario) FROM empregado ;
Ainda é possível filtrar os registros a serem utilizados na soma. Para saber quanto se gasta
com os salários dos empregados que recebem mais de R$ 3.000,00, basta incluir o parâmetro
WHERE e condicionar os registros a serem utilizados na soma, como mostra o comando SQL:
mysql> SELECT SUM(salario) FROM empregado WHERE salario > 3000 ;
Função AVG
A função AVG calcula a média de valores de uma coluna.
A sintaxe do comando SQL utilizando a função AVG é:
mysql> SELECT AVG(nome_da_coluna) FROM nome_da_tabela
Por exemplo, para saber qual é o salário médio dos empregados cadastrados:
mysql> SELECT AVG(salario) FROM empregado ;
Para formatar o valor médio, pode-se utilizar a função: FORMAT(número, casas_decimais).

SELECT FORMAT(AVG(salario), 2) AS Salario FROM empregado;
Assim como nas funções anteriores, é possível filtrar os registros que serão utilizados para
calcular o valor médio. Por exemplo, para saber o salário médio dos empregados que recebem mais
de R$ 3.000,00, o seguinte comando SQL pode ser utilizado:
mysql> SELECT AVG(salario) FROM empregado WHERE salario > 3000 ;
Função MAX
A função MAX serve para obter o valor mais alto (máximo) cadastrado em uma coluna.
A sintaxe do comando SQL utilizando a função MAX é:
mysql> SELECT MAX(nome_da_coluna) FROM nome_da_tabela

Por meio desse comando, é possível obter o maior salário registrado na tabela empregado:
mysql> SELECT MAX(salario) FROM empregado ;
A função MAX pode filtrar os registros a serem utilizados para obtenção do valor máximo.
Por exemplo, mostrar o salário mais alto entre os empregados com salario menor que R$ 3.000,00:
mysql> SELECT MAX(salario) FROM empregado WHERE salario < 3000 ;
Função MIN
A função MIN serve para obter o valor mais baixo (mínimo) cadastrado em uma coluna.
A sintaxe do comando SQL utilizando a função MIN é:
mysql> SELECT MIN(nome_da_coluna) FROM nome_da_tabela
Por meio desse comando, é possível obter o salário mais baixo registrado na tabela
empregado, como mostra o comando SQL a seguir:
mysql> SELECT MIN(salario) FROM empregado ;
A função MIN pode filtrar os registros a serem utilizados para obtenção do valor mínimo.
Por exemplo, para saber o salário mais baixo entre os empregados que recebem mais de R$
3.000,00, utilize o comando SQL a seguir:
mysql> SELECT MIN(salario) FROM empregado WHERE salario > 3000 ;
Vamos praticar!
Exercício 1) Mostrar todas as datas de demissão dos empregados, sem repetí-las.
Exercício 2) Mostrar quantos empregados pertencem ao departamento 10.
Exercício 3) Mostrar a quantidade de departamentos que têm empregados alocados.
Exercício 4) Mostrar em quantas datas de admissao diferentes os empregados foram contratados.
Exercício 5) Mostrar a soma dos salários dos empregados do departamento 10.
Exercício 6) Mostrar a média dos salários dos empregados do departamento 20.
Exercício 7) Mostrar o menor salário dos empregados do departamento 30.
Exercício 8) Mostrar a maior data_admissao (mais recente) dos empregados do departamento 40.

4.4.2.4. Parâmetro GROUP BY

O parâmentro GROUP BY tem funcionalidades para realizar operações (COUNT, SUM,
AVG, MAX e MIN) com base em agrupamentos de valores de uma coluna específica.
A sintaxe do comando SQL utilizando o parâmetro GROUP BY é:
GROUP BY nome_da_coluna [HAVING <condição> ] ;
Por exemplo, como fazer para calcular a média dos salários dos empregados para cada
departamento? Uma forma seria realizar um comando SQL para calcular a média (AVG) dos
salarios para cada departamento. Outra forma, é através de um único comando, automatizar essa
consulta por meio do parâmetro GROUP BY. O comando SQL a seguir mostra esta consulta:
mysql> SELECT dep_id, FORMAT(AVG(salario), 2) FROM empregado
> GROUP BY dep_id ;
Outro exemplo, desta vez utilizando o parâmetro WHERE: encontrar a quantidade de

empregados dos departamentos 10 e 20 (utilizando apenas um comando SQL):
mysql> SELECT dep_id, COUNT(*) FROM empregado
> WHERE dep_id = 10 OR dep_id = 20
> GROUP BY dep_id ;
Vamos praticar!
Exercício 1) Mostrar o número de empregados de cada departamento da tabela empregado.

Exercício 2) Mostrar a soma dos salários de cada departamento da tabela empregado.
Exercício 3) Mostrar o maior e o menor salário de cada departamento da tabela empregado.
Exercício 4) Mostrar a média dos salários dos empregados que possuem a mesma data de
demissao.
Exercício 5) Mostrar quantos empregados foram demitidos em cada data de demissão.

4.4.2.5. Argumento HAVING

O argumento HAVING é muito similar ao WHERE. É utilizado para filtrar quais registros
devem ser abordados na consulta em questão. A diferença é que o argumento HAVING deve ser
utilizado junto com o parâmentro GROUP BY, pois seu filtro é baseado em operações agrupadas
disponibilizadas por esse comando.
Para utilizar o parâmetro GROUP BY com o argumento HAVING, utilize a sintaxe:
GROUP BY nome_da_coluna HAVING <condição> ;
Por exemplo, para obter o salário médio dos empregados de cada departamento, mas exibir
apenas os departamentos cujos salários médios sejam menores que R$ 2.500,00:
mysql> SELECT dep_id, AVG(salario) FROM empregado
> GROUP BY dep_id HAVING AVG(salario) < 2500 ;
Outro exemplo, desta vez utilizando também o parâmetro WHERE: encontrar o salário
médio dos empregados dos departamentos 10 e 20, mas exibir apenas os departamentos cujos
salários médios sejam menores que R$ 2.500,00:
mysql> SELECT dep_id, AVG(salario) FROM empregado
> WHERE dep_id = 10 OR dep_id = 20
> GROUP BY dep_id HAVING AVG(salario) < 2500 ;
Vamos praticar!
Exercício 1) Mostrar o número de empregados que foram demitidos em cada data de demissão,
apenas os que realmente foram demitidos.
Exercício 2) Mostrar a quantidade de empregados e a soma do salários dos departamentos, com
excessão dos empregados do departamento 20.
Exercício 3) Mostrar a quantidade de empregados e a soma do salários dos departamentos, que
somam mais de 12.000, com excessão dos empregados do departamento 20.
Exercício 4) Mostrar o código do departamento e a respectiva quantidade de empregados, dos
departamentos que tem 2 ou mais empregados.
Exercício 5) Mostrar o código do departamento e a respectiva quantidade de empregados, dos
departamentos que tem 2 ou mais empregados, sem contar os demitidos.

4.4.2.6. Parâmetro ORDER BY

Como pode ser observado nos exemplos anteriores, os registros retornados não são
mostrados de forma ordenada. Normalmente é mais fácil examinar a saída da consulta quando os
registros são ordenados.
O parâmetro ORDER BY é utilizado para ordenar os registros de uma consulta de acordo
com uma coluna ou critério utilizado.
Sua utilização torna prática a visualização crescente ou decrescente de dados, além de
otimizar a captura do primeiro (menor valor) ou último (maior valor) registro de uma consulta.
A sintaxe do comando SQL utilizando o parâmetro ORDER BY é:
ORDER BY nome_da_coluna [ ASC | DESC ] ;
Caso o comando SQL esteja utilizando outros parâmetro, como WHERE ou GROUP BY,
recomenda-se que o parâmetro ORDER BY seja utilizado por último.
Para exibir, em ordem crescente de nome, a lista dos empregados, o seguinte comando SQL
deve ser utilizado:
mysql> SELECT * FROM empregado
> ORDER BY nome ;
Note que não foi especificado o argumento do parâmetro ORDER BY. Neste caso, a
ordenação é definida como crescente, sendo possível utilizar o argumento ASC para garantir esta
condição.
O parâmetro ORDER BY pode ser utilizado para a ordenação decrescente. O argumento
DESC, exibido no final da sintaxe, possibilita esta forma de ordenação.
O ORDER BY permite também definir mais de uma coluna como critério de ordenação.
Por exemplo, para ordenar o resultado da consulta de forma decrescente de salário e
crescente de nome. O seguinte comando SQL pode ser utilizado:
mysql> SELECT * FROM empregado
> ORDER BY salario DESC , nome ASC;

Note que a expressão DESC é aplicada somente para a coluna salario; ela não afeta a
ordenação da coluna nome. Neste exemplo, quando o salário dos empregados for igual, o segundo
critério de ordenação será utilizado. Caso contrário, o segundo critério de ordenação é ignorado.
Função LIMIT
A partir de uma consulta, é possível visualizar os primeiros N registros retornados, assim
como os últimos N. Esse tipo de operação otimiza recursos para realizar tarefas como mostrar os
cinco empregados que recebem maior salário, bem como, os três com menores salários.
A sintaxe do comando SQL utilizando a função LIMIT é:
mysql> SELECT nome_da_coluna FROM nome_da_tabela LIMIT x,y;
O valor de x na expressão indica quantos registros devem ser ignorados (pulados), e o valor
do y indica quantos devem ser exibidos a partir da posição x.
Por exemplo, para selecionar os três primeiros nomes em ordem alfabética da tabela
empregado, o seguinte comando SQL deverá ser utilizado:
mysql> SELECT nome FROM empregado ORDER BY nome LIMIT 0,3;
No caso da necessidade de obter os últimos três nomes, o argumento DESC deverá ser
utilizado, junto ao parâmetro ORDER BY, para inverter o resultado, como mostra o comando SQL a
seguir:
mysql> SELECT nome FROM empregado ORDER BY nome DESC LIMIT 0,3;
Vamos praticar!
Exercício 1) Selecionar os dados dos empregados em ordem crescente de salario.

Exercício 2) Selecionar os dados dos empregados em ordem decrescente de departamento.
Exercício 3) Selecionar os dados dos empregados em ordem crescente de data_admissao.
Exercício 4) Selecionar os dados dos empregados em ordem decrescente de departamento e
crescente de nome.
Exercício 5) Selecionar os dados dos empregados em ordem crescente de nome e decrescente de
departamento.
Exercício 6) Selecionar os dados dos empregados com os 5 maiores salários.
Exercício 7) Selecionar os dados dos empregados com os 2 menores salários do departamento 10.

4.4.3. Alterando dados na tabela

A sintaxe do comando SQL para alterar os dados de uma tabela é:
mysql> UPDATE nome_da_tabela
SET
nome_da_coluna = novo conteúdo para a coluna [ ,
nome_da_coluna = novo conteúdo para a coluna ]
[ WHERE condição ];
Por exemplo, o comando SQL para aumentar o salário em 10% de todos os empregados é:
mysql> UPDATE empregado
> SET salario = salario + salario * 0.1;
Se fosse para aumentar o salário em 10% apenas para os empregados com salário menor que
R$ 3.000,00, o comando SQL seria:
mysql> UPDATE empregado
> SET salario = salario + salario * 0.1
> WHERE salario <= 3000;
Note que no segundo exemplo, é especificada a condição WHERE. Neste caso, o aumento
será fornecido apenas aos empregados que tiverem a condição do WHERE satisfeita.
Vamos praticar!
Exercício 1) Aumentar o salário para todos os empregados, dando um aumento de 20%.

Exercício 2) Aumentar o salário em 10% somente aos empregados do departamento 20.
Exercício 3) Alterar a data de admissão para '1997/12/20' do empregados com codigo = 105.
Exercício 4) Alterar para dep_id = NULL, os empregados que já foram demitidos.
Exercício 5) Alterar o nome para 'João da Silva' o empregados com código 109.
Exercício 6) Alterar o nome do departamento 'Recursos Humanos' para 'RH'.

4.4.4. Excluindo dados na tabela

A sintaxe do comando SQL para excluir os dados de uma tabela é:
mysql> DELETE FROM nome_da_tabela
[ WHERE condição ];
Assim como os comandos SELECT e UPDATE, o parâmetro WHERE serve para filtrar os
registros, sendo no caso do DELETE, os que serão excluídos. Não utilizar o WHERE, implica na
remoção de todos os registros da tabela.
Por exemplo, para excluir o registro do empregado, cujo código é 145, o seguinte comando
SQL pode ser utilizado:
mysql> DELETE FROM empregado
> WHERE cod_emp = 145 ;
A execução deste comando deve ser realizada com atenção, pois não é mostrada nenhuma
mensagem de confirmação da sua execução.
Vamos praticar!
Exercício 1) Apagar da tabela departamento, o registro cujo codigo de departamento é 50.

Exercício 2) Apagar da tabela empregado, todos os registros com data de demissão no ano 2003.
4.4.5. Selecionando informações de tabelas diferentes
Até agora vimos apenas exemplos onde selecionávamos informações de uma única tabela.
Mas às vezes, é preciso mostrar resultados provenientes de duas ou mais tabelas.
Por exemplo, ao mostrar os dados dos empregados, deseja-se que ao invés de exibir o código
do departamento dos empregados, seja exibido o nome do departamento. Porém, esta informação
está armazenada na tabela departamento.
Para selecionar informações de tabelas diferentes, é preciso que elas tenham alguma relação
entre si. As tabelas empregado e departamento possuem este relacionamento, que é implementado
pela chave estrangeira. Vamos ver no exemplo a seguir como é fundamental o uso da chave
estrangeira para selecionar informações de tabelas diferentes.

Para unir as duas tabelas, pode-se utilizar o comando SQL:

mysql> SELECT e.cod_emp, e.nome, e.salario, d.nome
> FROM empregado e, departamento d
> WHERE d.cod_dep = e.dep_id ;
O comando acima pode ser entendido como:

“Selecione cod_emp, nome, salário (dos empregados) e nome (dos departamentos), das tabelas
empregado e departamento, onde o valor da coluna cod_dep da tabela departamento é igual ao
valor da coluna dep_id da tabela empregado.
Existem algumas informações que devem ser observadas nesta consulta:

• Em FROM:
◦ São listadas as duas tabelas porque a consulta precisa extrair informação de ambas.
◦ Foram especificados apelidos para as tabelas para indicar com qual tabela cada coluna
está associada.
• Em SELEC:
◦ Foram utilizados os apelidos das tabelas para indicar com qual tabela cada coluna está
associada. Isto é feito usando o apelido da tabela antes do nome da coluna separados por
um ponto “.”. Pode-se também usar o nome completo da tabela ao invés dos apelidos.
◦ Ambas tabelas possuem uma coluna nome, por isso deve-se especificar qual a tabela que
está sendo referenciada.
• O WHERE é utilizado para coincidir registros nas duas tabelas baseadas nos valores de
código de departamento, sendo na tabela departamento a coluna cod_dep e na tabela
empregado a coluna dep_id. Como vimos anteriormente, a coluna dep_id da tabela
empregado é a chave estrangeira para a coluna cod_dep da tabela departamento.
Vamos praticar!
Exercício 1) Selecionar nome e salario dos empregados e o nome dos respectivos departamentos,
dos empregados que têm salário maior que R$ 5.000,00.
Exercício 2) Selecionar nome, salário dos empregados e o nome dos respectivos departamentos,
dos empregados que não trabalham no departamento 10.

Exercício 3) Selecionar nome, salario dos empregados e o nome dos respectivos departamentos,
dos empregados com salário menor que R$ 4.000,00.
Exercício 4) Selecionar nome, salario dos empregados e o nome dos respectivos departamentos,
dos empregados com data de admissão no ano 2010 e código maior ou igual a 100.
Exercício 5) Mostrar nome dos departamentos e a quantidade de empregados alocados neles.
Exercício 6) Mostrar a soma dos salários dos empregados de cada departamento, e o nome do
departamento.
Exercício 7) Mostrar a média dos salários dos empregados de cada departamento, e o nome do
departamento.
Exercício 8) Mostrar o maior e o menor salário de cada departamento, mostrando o nome do

departamento.
Exercício 9) Mostrar o nome dos departamentos cujo soma dos salários dos empregados é acima
de R$ 12.000,00.
Exercício 10) Mostrar o nome dos departamentos cujo soma dos salários dos empregados é acima
de R$ 5.000,00, mas que não sejam do departamento com código 10.
Exercício 11) Mostrar o codigo e nome dos departamentos cuja a soma dos salarios dos
empregados é acima de R$ 6.500,00. Nesta soma, considere apenas os salarios dos empregados
que recebem mais de R$ 3.400,00.
Exercício 12) Mostrar o nome dos empregados e seus respectivos departamentos, ordenando o
resultado em ordem crescente de nome de departamento.
Exercício 13) Mostrar o nome e salario dos empregados e seus respectivos departamentos,
ordenando o resultado em ordem decrescente de salario.
Exercício 14) Mostrar o nome dos empregados e departamentos, em ordem crescente de nome
departamento e decrescente de nome de empregado.
Exercício 15) Mostrar o nome e salario dos empregados e nome dos seus departamento, em ordem
crescente de nome departamento e crescente de salario.

4.5. DCL - Linguagem de Controle de Dados
Os principais comandos DCL são: GRANT e REVOKE. Nesta lição veremos uma breve
introdução sobre os comandos GRANT e REVOKE, pois a sintaxe deles é um pouco complicada,
sendo mais fácil utilizar, para estas tarefas, ferramentas gráficas de administração de BD.
Ao executar um comando GRANT para um usuário que não existe, o mesmo será criado.
Caso contrário, o GRANT, adicionará os novos privilégios aos já concedidos anteriormente.
A sintaxe do comando GRANT é:
mysql> GRANT privilégios [ colunas ]
ON item
TO usuario IDENTIFIED BY 'senha_do_usuario'
[ WITH GRANT OPTION ] ;
• privilégios: pode ser uma ou mais das seguintes opções (separadas por vírgula):
PRIVILÉGIO PERMISSÃO OBSERVAÇÃO
SELECT selecionar linhas (registros) aplicado a tabelas e colunas
INSERT inserir linhas aplicado a tabelas e colunas
UPDATE alterar valores em linhas aplicado a tabelas e colunas
DELETE apagar linhas aplicado a tabelas
INDEX criar e excluir índices aplicado a tabelas
alterar tabelas(adicionar colunas,
ALTER renomear colunas ou tabelas, alterar aplicado a tabelas
tipos de dados de colunas)
aplicado a banco de dados e tabelas. Se o
comando GRANT for especificado com um
banco de dados ou tabela em particular, só
CREATE criar banco de dados ou tabela
poderá ser criado esse banco ou tabela, o
que significa que eles terão que ser
excluídos primeiro (DROP)
DROPapagar banco de dados ou tabela aplicado a banco de dados e tabelas
recarregar tabelas grant e revogar
RELOAD deve ser concedido apenas a administradores
privilégios, hosts, logs e tabelas
SHUTDOWN desligar o servidor MySQL deve ser concedido apenas a administradores
visualizar processos do servidor e
PROCESS deve ser concedido apenas a administradores
eliminá-los
ler e transferir dados entre tabelas e
FILE deve ser concedido apenas a administradores
arquivos
ALL tudo deve ser concedido apenas a administradores
isto apenas cria um usuário e o permite
USAGE nada
efetuar o logon, mas não permite nada

• colunas: é opcional e especifica as colunas a que os privilégios se aplicam. Pode ser uma
única coluna ou várias (separadas por vírgula);
• item: é o banco de dados ou tabela a que os privilégios se aplicam. É especificado como:
• *.* - neste caso os privilégios aplicam-se a todos os bancos de dados;

• * - idem se não estiver utilizando nenhum banco de dados em particular;
• banco.* - neste caso os privilégios aplicam-se a todas as tabelas do banco;
• banco.tabela - neste caso os privilégios aplicam-se a uma determinada tabela. Pode-
se, ainda, especificar alguma(s) coluna(s) em particular inserindo esta(s) em colunas;
• Se estiver usando um banco de dados em particular, apenas o nome da tabela será

suficiente para item. A tabela será interpretada como sendo do banco de dados atual;
• usuário: especifica um usuário do MySQL;
• senha: é a senha do usuário para acessar o servidor MySQL;
• WITH GRANT OPTION: se este parâmetro for especificado, o usuário pode conceder
seus privilégios a outros usuários do MySQL.
A sintaxe do comando REVOKE para revogar privilégios de acesso é:

mysql> REVOKE privilégios [ colunas ]
ON item
FROM usuario ;
Se foi concedido ao usuário privilégios com WITH GRANT OPTION, pode-se revogá-lo
com o comando:
mysql> REVOKE GRANT OPTION
ON item
FROM usuario ;
Podem ser passados outros argumentos ao comando GRANT e REVOKE. Para mais
informações, acesse o site da documentação do MySQL (http://dev.mysql.com/doc/).

4.5.1. Níveis de Privilégios

Os comandos GRANT e REVOKE permitem aos administradores do sistema, criar usuários
e conceder e revogar direitos aos usuários do MySQL em quatro níveis de privilégios:
• Nível Global: privilégios globais aplicam para todos os bancos de dados em um
determinado servidor. Estes privilégios são armazenados na tabela mysql.user. GRANT ALL
ON *.* e REVOKE ALL ON *.* concederão e revogarão apenas privilégios globais.
• Nível dos bancos de dados: privilégios de bancos de dados aplicam-se a todas as tabelas em
um determinado banco de dados. Estes privilégios são armazenados nas tabelas mysql.db e
mysql.host. GRANT ALL ON db.* e REVOKE ALL ON db.* concederão e revogarão
apenas privilégios de banco de dados.
• Nível das tabelas: privilégios de tabelas aplicam-se a todas as colunas em uma determinada
tabela. Estes privilégios são armazenados na tabela mysql.tables_priv. GRANT ALL ON
db.table e REVOKE ALL ON db.table concederão e revogarão apenas privilégios de tabelas.
• Nível das colunas: privilégios de colunas aplicam-se a uma única coluna em uma
determinada tabela. Estes privilégios são armazenados na tabela mysql.columns_priv.
4.5.2. Adicionando Novos Usuários

Existem três maneiras de adicionar usuários no MySQL:
1. Utilizando o comando GRANT;
2. Utilizando ferramentas gráficas de administração do MySQL;
3. Manipulando as tabelas de permissões do MySQL (não recomendado).
Neste curso, veremos como adicionar novos usuários do MySQL utilizando o comando
GRANT. Posteriormente, veremos uma das várias ferramentas gráficas, o PhpMyAdmin, que pode
ser utilizado para administrar usuários no MySQL entre outras ações.
Os exemplos a seguir mostram como criar três novos usuários para acesso ao banco de
dados mysql, utilizando o comando GRANT:
Primeiro, com o usuário root, conectar ao banco de dados mysql:
mysql u root p mysql
• Usuário monty: superusuário completo que pode conectar ao servidor de qualquer lugar,
mas deve utilizar uma senha @123#ABC para fazer isto. Perceba que devemos utilizar o
comando GRANT para monty@localhost e monty@"%". Se não adicionar a entrada com

localhost, a entrada para o usuário anônimo para localhost que é criada por
mysql_install_db, toma precedência quando o usuário conectar-se da máquina local, porque
ele contém um campo host com um valor mais específico e também vem antes na ordenação
da tabela user.
mysql> GRANT ALL PRIVILEGES ON *.* TO monty@localhost IDENTIFIED BY

' @123
#ABC' WITH GRANT OPTION ;
mysql> GRANT ALL PRIVILEGES ON *.* TO monty@'%' IDENTIFIED BY

' @123
#ABC' WITH GRANT OPTION ;
• Usuario admin: usuário que pode conectar de localhost sem uma senha e que é concedido
os privilégios administrativos reload e process. Isto permite ao usuário a execução dos
comandos mysqladmin reload, mysqladmin refresh, mysqladmin flush-* e mysqladmin
processlist. Nenhum privilégio a nível de bancos de dados é concedido.
mysql> GRANT RELOAD,PROCESS ON *.* TO admin@localhost ;
• Usuario dummy: usuário que pode conectar sem uma senha, mas somente do localhost.
Não são concedidos nenhum privilégio (o tipo de privilégio USAGE permite a criação de
um usuário sem privilégios). Ele tem o efeito de criar todos os privilégios globais com 'N'.
Considera-se que serão concedidos privilégios específicos a conta posteriormente.
mysql> GRANT USAGE ON *.* TO dummy@localhost ;
4.5.3. Revogando privilégios

Para remover todos os privilégios do usuário com o comando REVOKE, use o comando:
mysql> REVOKE ALL PRIVILEGES ON bancodedados.* FROM usuario; ;
4.5.4. Removendo Usuários

Para remover o usuário dummy do MySQL, use o comando:
mysql> DELETE FROM mysql.user WHERE User = 'dummy' ;

Na lição a seguir veremos como adicionar e remover usuário e privilégios utilizando a

ferramenta PhpMyAdmin.

Aqui vimos os principais comandos SQL para definir, manipular e controlar
bancos de dados e tabelas.

5. Ferramentas de Administração
Nesta lição veremos como administrar o MySQL utilizando uma ferramenta gráfica.
Bom estudo!
5.1. PhpMyAdmin
Como visto na lição anterior administrar contas de usuário por linhas de comando é muito
complicado. Para facilitar esta e outras tarefas administrativas existem ferramentas gráficas que
auxiliam na utilização do MySQL.
Entre as várias ferramentas gráficas existentes, podemos citar o PhpMyAdmin. O
PhpMyAdmin é uma ferramenta de uso gráfico simples e prática para auxiliar no gerenciamento e
na administração do servidor e dos bancos de dados do MySQL.
Por meio de uma interface gráfica web, disponibiliza alguns dos recursos mais utilizados do
MySQL, como criação de bancos de dados, criação e manutenção de tabelas e gerenciamento de
processos, de forma rápida e intuitiva para o usuário.
O PhpMyAdmin apenas automatiza algumas das linhas de comandos mais frequentes do
MySQL. Não existe nenhum recurso exclusivo do PhpMyAdmin que não possa ser feito a partir do
terminal do MySQL. Muito pelo contrário, nem tudo que pode ser feito via terminal poderá ser feito
com o uso do PhpMyAdmin.
O grande objetivo do PhpMyAdmin é tornar mais simples e pratica a interação com o
MySQL, utilizando os conceitos de programação gráfica.
5.1.1. Instalando o PhpMyAdmin

A instalação do PhpMyAdmin é muito simples, uma vez que temos os caminhos para os
repositórios configurados corretamente a instalação, digite no Terminal do sistema operacional:
aptget install phpmyadmin
Basta responder Sim para as perguntas e pronto. Também será necessário instalar o Apache,
porém esse processo é realizado com a instalação do pacote do PhpMyAdmin.

5.1.2. Acessando o PhpMyAdmin

Depois de instalado, pode-se acessar o PhpMyAdmin pelo navegador web digitando a url:
http://<ip_do_servidor_web>/phpmyadmin
Caso o servidor esteja na máquina onde está sendo acessado o PhpMyAdmin, basta digitar:
http://localhost/phpmyadmin
Aparecerá uma tela, como a mostrada na figura a seguir, solicitando o Usuário e Senha.
Figura 16: Tela de login do PhpMyAdmin
Informe os mesmos usuário e senha utilizados para acesso ao MySQL no terminal. Caso o
MySQL seja recém-instalado, o usuário será root e a senha criada na instalação do MySQL.

5.1.3. Tela Inicial

Depois da autenticação, será exibida a tela do PhpMyAdmin como mostra a figura a seguir.
Figura 17: Tela inicial do PhpMyAdmin
Nesta tela têm vários menus, a partir dos quais pode-se configurar as principais funções do
PhpMyAdmin.
Vamos ver os menus com um pouco mais de detalhe.
1 2 3 4 5 6
1 Principal: tela inicial do PhpMyAdmin

2 Sair: sai do sistema com segurança
3 Janela de Consulta: abre janela para execução de comandos SQL.
4 Documentação do PhpMyAdmin
5 Documentação do MySQL
6 Atualização do navegador

1
2
1 Barra, em forma de link, construída a partir da navegação do usuário.

2 Menus que são modificados conforme o objeto selecionado.
3 Campo para alterar senha do usuário.
4 Campo que permite mudar o idioma do PhpMyAdmin.
A seguir veremos as funções principais do PhpMyAdmin.
5.1.4. Principais Funções do PhpMyAdmin

5.1.4.1. Criando um banco de dados
Para criar um banco de dados no PhpMyAdmin:
1. Clique no menu Banco de Dados.
Aparecerá uma tela como a mostrada na
figura ao lado.
2. No campo Criar novo Banco de Dados,

digite o nome do banco de dados a ser
criado. Os bancos de dados já existentes
também são mostrados.
Figura 18: Menu Banco de Dados

5.1.4.2. Selecionando um banco de dados

Para selecionar um banco, a partir na tela inicial do PhpMyAdmin, existem várias formas:
1. Clique sobre o nome correspondente no menu Esquerdo.
2. Selecione o menu Banco de Dados e clique sobre o nome do banco.
Com o banco de dados selecionado é possível renomeá-lo, copiá-lo e apagá-lo. Para isso,
selecione o menu Operações.
5.1.4.3. Criando uma tabela

Para criar uma tabela no PhpMyAdmin:
1. Selecione o banco de dados onde será criada a tabela e selecione o menu Estrutura.
Aparecerá uma tela como a mostrada a seguir.
Figura 19: Criando uma nova tabela
2. No campo Criar nova tabela no Banco de Dados curso, digite o nome da tabela a ser
criada e o número de colunas que a tabela terá. Depois clique no botão Executar. Ou clique
no botão Create table localizado no menu esquerdo.
3. Em seguida, aparecerá uma tela onde devem ser preenchidos os nomes das colunas da tabela
e seus respectivos tipos de dados. Lembre-se de informar, no campo Tamanho/Definir, o
número de caracteres para tipos de dados CHAR e VARCHAR. Nesta tela também pode ser
configurado se a coluna será Índice (PRIMARY, UNIQUE, INDEX) e/ou AUTO-
INCREMENT.
4. Depois de preencher as informações solicitadas, clique em Salvar ou Executar.

5.1.4.4. Alterando a estrutura de uma tabela
Para alterar a estrutura das colunas de uma tabela utilizando o PhpMyAdmin:
1. Clique sobre o nome da tabela, no menu Esquerdo, e selecione o menu Estrutura.

Figura 20: Alterando a estrutura da tabela
2. Serão mostradas as colunas da tabela com várias ações que podem ser executadas em cada
uma delas: Alterar (a estrutura da coluna), Eliminar, Adicionar chave primária, etc.
Nesta tela pode-se ainda Adicionar novas colunas (No final da tabela, No início da tabela
ou ainda Depois de uma coluna especificada). Também é possível Criar, Editar ou Eliminar Índices.
Para renomear a tabela utilizando o PhpMyAdmin:
1. Clique sobre o nome da tabela, no menu Esquerdo, e selecione o menu Operações.


Figura 21: Operações com tabelas
2. No campo Renomear a tabela para, informe o novo nome da tabela.
3. Depois clique em Executar.
Nesta tela também é possível Mover/Copiar a tabela para outro banco de dados. E ainda,
Esvaziar a tabela, mantendo a estrutura da tabela ou Remover a tabela, eliminando a estrutura e
dados.
5.1.4.5. Deletando uma tabela
Para apagar uma tabela utilizando o PhpMyAdmin, existem várias formas:
1. Selecione o banco de dados onde está a tabela que será excluída, selecione o menu
Estrutura e clique na opção Eliminar correspondente à tabela.
2. Selecione a tabela que será excluída, selecione o menu Operações e clique na opção
Remover a tabela (Drop).

5.1.4.6. Inserindo dados em uma tabela
Para inserir dados em uma tabela utilizando o PhpMyAdmin, existem várias formas:
1. Selecione o banco de dados onde está a tabela, selecione o menu Estrutura e clique na
opção Inserir correspondente à tabela.
2. Selecione a tabela, no menu esquerdo e selecione o menu Inserir.
Depois, preencha os campos com as informações desejadas e clique em Executar.
Existe ainda uma outra forma de inserir dados em uma tabela:

1. Selecione a tabela, no menu esquerdo, e selecione o menu SQL.
2. Digite o comando SQL e clique no botão Executar.
5.1.4.7. Selecionando dados em uma tabela
Para selecionar os dados em uma tabela utilizando o PhpMyAdmin, existem várias formas:
1. Selecione o banco de dados onde está a tabela, selecione o menu Estrutura e clique na
opção Visualizar correspondente à tabela.
2. Selecione a tabela, no menu esquerdo, e selecione o menu Visualizar.
Nesta tela também é possível Editar, Copiar e Eliminar os dados.
Existe ainda uma outra forma de selecionar dados em uma ou mais tabelas:
1. Selecione a tabela, no menu esquerdo e selecione o menu SQL.
5.1.4.8. Alterando dados em uma tabela
Para alterar os dados em uma tabela utilizando o PhpMyAdmin:

1. Selecione a tabela onde estão os dados que serão alterados e selecione o menu Visualizar.
2. Selecione a opção Editar correspondente aos dados a serem alterados.
3. Faça as alterações e clique em Executar.
Existe ainda uma outra forma de alterar os dados em uma tabela:
1. Selecione a tabela, no menu esquerdo, e selecione o menu SQL.

5.1.4.9. Excluindo dados de uma tabela
Para excluir os dados de uma tabela utilizando o PhpMyAdmin:

1. Selecione a tabela onde estão os dados que serão excluídos e selecione o menu Visualizar.
2. Selecione a opção Remover correspondente aos dados a serem excluídos.
3. Clique em OK para confirmar a exclusão.
Existe ainda uma outra forma de excluir os dados em uma tabela:
1. Selecione a tabela, no menu esquerdo e selecione o menu SQL.
5.1.4.10. Adicionando novos usuários
Para adicionar novos usuários utilizando o PhpMyAdmin:
1. Acesse a tela inicial do PhpMyAdmin (clique no link localhost no topo da tela ou no ícone
Principal, no menu esquerdo).
2. Selecione o menu Privilégios e clique na opção Adicionar novo usuário.
3. Informe o nome do usuário, a senha de acesso e o Servidor e selecione os privilégios globais

no sistema.
4. Depois, clique em Criar usuário.
5.1.4.11. Concedendo privilégios em banco de dados e tabelas específicos
Para conceder privilégios de banco de dados ou tabela específicos aos usuários:
1. Acesse a tela inicial do PhpMyAdmin.
2. Selecione o menu Privilégios.
3. Clique em Editar Privilégios correspondente ao usuário.
4. Selecione o banco de dados em Privilégios específicos do Banco de Dados
5. Marque os Privilégios específicos do Banco de Dados e/ou os Privilégios específicos da

tabela.
6. Clique em Executar.

5.1.4.12. Editando privilégios concedidos
Para editar os privilégios dos usuários:
1. Acesse a tela inicial do PhpMyAdmin
3. Clique em Editar Privilégios.
4. Em Privilégios globais os itens marcados correspondem aos privilégios concedidos a todos

os bancos.
5. Em Privilégios específicos do Banco de Dados aparecem os privilégios concedidos aos

bancos e/ou tabelas especificados. Para editá-los, clique em Editar Privilégios.
6. Depois de fazer as alterações, clique em Executar.
Para editar os privilégios concedidos em um banco específico:
2. Selecione o menu Banco de Dados.
3. Clique na opção Ver privilégios correspondente ao banco de dados.
4. Depois clique em Editar Privilégios (idem Passo 3 para “Editar privilégios”).
5.1.4.13. Revogando privilégios
Para revogar os privilégios concedidos:

3. Clique em Editar Privilégios.
1. Para Privilégios Globais: desmarque os privilégios concedidos e clique em Executar.
2. Para Privilégios Específicos: clique em Revogar correspondente ao banco/tabela.

5.1.4.14. Excluindo usuários
Para remover usuários utilizando o PhpMyAdmin:
2. Selecione o menu Privilégios, marque o(s) usuário(s) que será(ão) excluído(s).
3. Em Remover os usuários selecionados, clique em Executar.
5.1.4.15. Exportando o Banco de Dados
Para exportar banco de dados utilizando o PhpMyAdmin:
2. Selecione o menu Exportar, selecione o Método de Exportação (Rápida ou Customizada) e

o Formato do arquivo (preferencialmente o SQL).
3. Depois clique me Executar.
4. Selecione o local onde deseja salvar o arquivo e clique em OK.
5.1.4.16. Importando Banco de Dados para o MySQL
Para importar banco de dados utilizando o PhpMyAdmin:
2. Selecione o menu Importar, clique no botão Selecionar o arquivo para localizar arquivo e
selecione o Formato do arquivo (preferencialmente o SQL).
3. Depois clique me Executar.
Finalizamos esta breve introdução sobre esta ferramenta de administração. Caso queira
encontrar mais informações sobre o PhpMyAdmin pode acessar o site da ferramenta
(http://www.phpmyadmin.net).

5.2. Ferramenta de Backup
Existem duas formas de fazer backup do banco de dados no MySQL:

• Backup Físico: copia os arquivos e diretórios do banco de dados, sendo que o MySQL deve
estar OFFLINE, ou seja, o MySQL não pode estar rodando. O backup gerado é portável
apenas para máquinas semelhantes ao servidor original.
• Backup Lógico: é feito através do servidor MySQL, ou seja, o servidor deve estar
ONLINE. Normalmente é mais lento que um Backup Físico e o arquivo gerado é maior e
também é portável.
Devido sua facilidade de uso, o Backup Lógico é mais utilizado. A principal ferramenta para
criar o Backup Lógico no MySQL é o MySQLDUMP. O MySQLDUMP é a ferramenta padrão do
MySQL para efetuar Backup Lógico disponibilizado na sua instalação. Ele possibilita a cópia de
bancos de dados que estão dentro do SGBD MySQL. É útil para fazer cópias de segurança de
bancos de dados ou transferir conteúdos de bancos de dados para outro servidor.
O MySQLDUMP pode produzir arquivos no formato SQL que contenham declarações
CREATE TABLE e INSERT para recriar os arquivos ou para produzir arquivos de dados
delimitados por tabulações. Esta ferramenta é executada na linha de comando do Linux e o backup
é gerado na forma de um arquivo texto que pode ser editado, copiado ou compactado.
Para gerar o arquivo de backup utilizando o MySQLDump, execute no terminal do Linux
(não do MySQL) o comando:
mysqldump u usuario p B nome_bd v > nome_arquivo.sql
-u: indica que a informação seguinte é o nome do usuário.

-p: indica que deve ser solicitada a senha de acesso ao banco (a mesma usada para acesso ao
MySQL).
-B: indica para incluir o banco de dados no backup.
-v: mostra informações sobre o que o comando executa.
> nome_arquivo.sql: indica que é para colocar as informações do backup no arquivo chamado
nome_arquivo.sql. O arquivo será gerado no local onde o prompt do terminal estiver posicionado.
Para salvar em outro local, basta indicar o caminho antes do nome do arquivo. Por exemplo:
mysqldump u root p B curso v > /<caminho>/backup.sql
Neste caso, será preciso indicar o caminho /<caminho>/backup.sql sempre que for utilizar
este arquivo.

Para excluir o BD utilizando o MySQLDUMP, execute no terminal do Linux o comando:

mysqldump u usuario p drop nome_bd
Para restaurar o BD utilizando o MySQLDUMP, execute no terminal do Linux o comando:

mysqldump u usuario p < backup.sql
Para gerar o backup do banco curso, sem a opção de criação do banco (-B), compactando o
arquivo de saída no formato gzip, execute no terminal do Linux o comando:
mysqldump u root p curso | gzip 9 > backup.sql.gz
Para excluir o BD curso, utilizando o comando MySQLAdmin, execute no terminal do

Linux o comando:
mysqladmin u root p drop curso
Para criar um novo BD, uma vez que o último backup foi criado sem o banco, execute no
terminal do Linux o comando:
mysqladmin u root p create curso
Para descompactar o arquivo e restaurar o backup, execute no terminal do Linux o comando:

gunzip c backup.sql.gz | mysql u root p curso
Para listar os BD do MySQL, sem precisar entrar no sistema, execute no terminal do Linux
o comando:
mysqlshow p
Com estes comandos, é possível fazer backup e até copiar o BD para outro computador.

Aqui vimos algumas ferramentas para facilitar a execução de tarefas no MySQL,
como: o PhpMyAdmin e o MySQLDUMP.

Conclusão
Vimos neste curso:

Lição 1 - Introdução ao SGDB
Lição 2 - Projeto de Banco de Dados
Lição 3 - SGBD MySQL
Lição 4 - Comandos SQL
Lição 5 - Ferramentas de Administração
Estamos chegando ao final do curso de Banco de Dados MySQL!

Para completar o curso vamos fazer alguns exercícios!
Acesse o Portal de Ensino do 1º CTA e faça a Avaliação Final.

Banco de Dados MySQL

Enviado por

Dados do documento

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

Banco de Dados MySQL

Enviado por

Direitos autorais:

Formatos disponíveis

MINISTÉRIO DA DEFESA

Seção de Treinamento do 1º CTA

Seção de Treinamento do 1º CTA - Maio 2014

1.1. O que é o SGBD?

1.2. Sistema de Processamento de Arquivos

Seção de Treinamento do 1º CTA - Maio 2014

Esses programas são desenvolvidos por programadores em resposta às necessidades desta

Seção de Treinamento do 1º CTA - Maio 2014

1.3. Características do SGBD

Seção de Treinamento do 1º CTA - Maio 2014

Seção de Treinamento do 1º CTA - Maio 2014

1.5. Tipos de SGBD

1.6. Modelo de Dados Relacional

Seção de Treinamento do 1º CTA - Maio 2014

As tabelas associam-se entre si através de regras de relacionamentos. Por exemplo, a tabela

Estamos chegando ao final desta lição!

Seção de Treinamento do 1º CTA - Maio 2014

2. Projeto de Banco de Dados

2.1. Modelagem de dados

Seção de Treinamento do 1º CTA - Maio 2014

2.2. Modelo Conceitual

2.2.1. Modelo Entidade e Relacionamento

Seção de Treinamento do 1º CTA - Maio 2014

Assim, podemos identificar as entidades do nosso MER: Empregado e Departamento.

Figura 1: Entidades representadas por Retângulos no DER

Seção de Treinamento do 1º CTA - Maio 2014

nome salario data_admissao

Figura 2: Atributos da entidade Empregado

• Atributo composto: podem ser divididos em partes menores, ou subpartes, os quais

Figura 3: Atributo composto representado no DER

• Atributo multivalorado: quando possuem um ou mais valores. Exemplo: Telefone. Um

Seção de Treinamento do 1º CTA - Maio 2014

Figura 4: Atributo multivalorado representado no DER

• Atributo chave: um aspecto importante no conceito de entidade e atributos é a possibilidade

Figura 5: Atributo chave representado no DER

Depois de definir as entidades e atributos, é preciso relacionar as entidades de um MER. O

Seção de Treinamento do 1º CTA - Maio 2014

empregado aloca departamento

Figura 6: Relacionamento representado no DER

Para identificar os relacionamentos da empresa ABC pode-se perguntar: Como um empregado

Dependendo da resposta fornecida pelo cliente, o relacionamento poderá ser do tipo:

Figura 7: Relacionamento um-para-um no DER

Seção de Treinamento do 1º CTA - Maio 2014

• um-para-muitos (1: N ou N:1)

Figura 8: Relacionamento um-para-muitos no DER

Figura 9: Relacionamento muitos-para-muitos no DER

Depois de definir o relacionamento entre as entidades é preciso identificar a cardinalidade

Seção de Treinamento do 1º CTA - Maio 2014

De acordo com as respostas anteriores, temos que a cardinalidade expressa no

Figura 10: Exemplo de cardinalidade

Seção de Treinamento do 1º CTA - Maio 2014

Por sua vez, a cardinalidade mínima especifica se a participação de todas as ocorrências

Vamos ver como ficou nosso DER completo.

cod_emp nome cod_dep nome

salario data_admissao data_demissao

Figura 11: DER da empresa ABC

Nosso Modelo Conceitual está concluído!

Seção de Treinamento do 1º CTA - Maio 2014

2.3. Modelo Lógico

Seção de Treinamento do 1º CTA - Maio 2014

Figura 12: Os atributos e as tuplas de uma tabela Cliente

2.3.1. Transformação do Modelo Conceitual em Modelo Lógico

2) Identifique as colunas que são chave identificadora da tupla e sublinhando-o.

3) Defina o tipo de dados que cada coluna irá armazenar.