Curso de MySQL - Curso em Vídeo

Ministrado por Gustavo Guanabara

Por Wesllen do Carmo Araújo

1
 SUMÁRIO
Capítulo I - Origem dos bancos de dados............................................................................................3
Modelo Relacional(MR).................................................................................................................. 8
Capítulo II - Criando o primeiro banco de dados...............................................................................13
Criando o banco de dados no MySQL Workbench........................................................................17
Criação de um banco de dados na prática......................................................................................20
Inserindo Dados na Tabela(INSERT INTO).................................................................................. 24
Alterando a Estrutura da Tabela(ALTER TABLE e DROP TABLE)............................................28
Manipulando Linhas(UPDATE, DELETE e TRUNCATE)...........................................................37
Capítulo III - Gerenciando Cópias de Segurança MySQL.................................................................45
Criar um novo banco de dados...................................................................................................... 57
Capítulo V - Obtendo Dados das Tabelas...........................................................................................70
Selecionando Linhas...................................................................................................................... 75
Operações Lógicas.........................................................................................................................76
Classificação do comando select................................................................................................... 81
Capítulo IV - Modelo Relacional....................................................................................................... 99
Chaves Estrangeiras.....................................................................................................................101
JOIN.............................................................................................................................................109
INNER JOIN com Várias Tabelas............................................................................................... 112

2
 Capítulo I - Origem dos bancos de dados
Dec. 50
Na década de 50, onde os apenas existiam computadores em universidades e bases militares os
dados eram registrados em papel. Naquela época, os dados eram escritos num papel e guardados em
uma pasta, e depois armazenadas em um arquivo metálico.

Figura 1: Captura de tela tirado de uma aula do curso de MySQL do Curso em Vídeo.
Fichas»»»»»»»»»»»»»»»»»»»»»»»»Pasta»»»»»»»»»»»»»»»»»»»»»»»»»»»Arquivo

Fichas > Pasta > Arquivo

Mesmo depois de todos esses anos, esse modelo ainda é conhecido atualmente na área de banco
de dados, mas de um jeito modernizado. Veja abaixo:

Registros»»»»»»»»»»»»»»»»»»»»»»Tabelas»»»»»»»»»»»»»»»»»»»»»»»»»Arquivo

Registros > Tabelas > Arquivo

Com a quantidade de pastas com fichas guardadas em arquivos(armários), houve um grande

problema no fim da década de 50 e início da de 60: o grande acúmulo de papel.

3
Dec. 60
Com o grande problema do grande acúmulo de papel na década de 50, entre o fim da década de
50 e início da década de 60 os dados passaram a ser digitalizados em computadores, pois os
computadores passaram a ganhar o mundo das empresas; diminuindo seu tamanho e tornando
necessários para guardar dados. Porém os registros eram guardados de forma bem arcaica, onde os
registros eram gravados em um arquivo sequencial, isso porque os arquivos antigamente eram
guardados em fitas magnéticas ou outros arquivos sequenciais; então para se conseguir achar algum
dado, era necessário varrer todos os dados sequenciais até achar o que se procurava. E esse tipo de
arquivo eram conhecidos como arquivos sequenciais. Mesmo sendo muito pior do que temos hoje,
os arquivos sequenciais eram melhor do que o seu antecessor—armazenamento de pastas em
arquivos(armários) de forma física.

Alguns anos depois, foram criados os primeiros discos(disquetes e HDs), onde esses discos
armazenavam os dados de maneira direta, ou seja, não era necessário varrer todos os registros para
encontrar um específico. Nesse mecanismo de armazenamento era possível guardar todos os
registros e mantê-los em tabelas numeradas com chaves identificadoras de cada um dos registros—
índices. E a com esse tipo de armazenamento, o tempo de procura por registros foi diminuído
significativamente. E esses tipos de arquivos eram conhecidos como arquivos de acesso direto.
Porém esse tipo de armazenamento tinha um problema: era muito simplista.
Ainda na década de 60, o USDOD(Departamento de Defesa dos EUA) ficou encarregado de
criar uma maneira de armazenar dados de maneira segura e inteligente.

CODASYL
O USDOD criou um evento chamado CODASYL—uma reunião entre militares, universidades e
empresas—onde foi discutido várias tecnologias emergentes, coisas que poderiam ser criadas, e
uma delas foi o COBOL—uma das linguagens de programação mais importantes da época—, que
foi a primeira linguagem de programação que não apenas se preocupava com a lógica de
programação, mas também na segurança de seus dados—. E, no CODASYL, também foi discutido
o surgimento de uma nova tecnologia: Banco de Dados.

4
 Princípios de Banco de Dados

Até hoje, banco de dados é composto por quatro princípios:

• Base de dados: Que são os dados propriamente ditos, as estruturas;

• Sistema Gerenciador: Além de dados, um banco de dados precisa ter um sistema
gerenciador dentro de sua estrutura que gerencia esses dados. Ex.: SGBD(Sistema
Gerenciador de Banco de Dados) em português e DMS(Data Menagment System =
Sistema de Gerenciamento de Dados) em inglês;
• Linguagem de Exploração: De acordo com a teoria criada no CODASYL, você só
precisaria conhecer uma linguagem—linguagem de acesso aos dados, que é uma
linguagem de exploração—;
• Programas Adicionais: Coisas adicionais como gerência de usuários, otimização de
dados, etc.

Além do USDOD, a IBM—empresa global de tecnologia e consultoria, que deu origem a uma
das maiores empresas de tecnologia do mundo—teve um papel importante na construção e evolução
dos bancos de dados, onde ela propôs a criação de dados hierárquicos, onde dados seriam
interligados de forma simplista mas hierárquico; ficando conhecido como modelo hierárquico.

MODELO HIERÁRQUICO

E, como uma evolução do modelo hierárquico, foi criado um outro modelo, o modelo em rede,
onde os dados não teriam uma separação de qual dado é superior ou inferior, mas sim interligados
em uma forma de rede inteligente.

MODELO EM REDE

5
 Com os modelos hierárquico e de rede, se tornou possível armazenar facilmente dados de
clientes, serviços, funcionários, empresas, fornecedores e etc., porém havia um problema: eles não
facilitavam uma coisa simples, o relacionamento de dados, onde um conjunto de dados poderiam se
relacionar com outro conjunto de dados(conjunto de registros de uma tabela que se relacionam com
outro conjunto de registros em outra tabela).

6
Déc. De 70
Com o surgimento do problema de relacionar dados na década de 60, Edgar F. Codd—um dos
pesquisadores da IBM—propôs um novo modelo, onde os dados seriam armazenados e em vez de
hierarquias ou ligações de redes, eles teriam ligações intrínsecas; ficando conhecido como modelo
relacional(MR).

7
Modelo Relacional(MR)

A criação do Modelo Relacional(MR) foi muito importante, pois ele permitia coisas como: se
eu tenho o cadastro de algum cliente, eu posso guardá-la no meu banco de dados, e então ter acesso
a todos os dados do meu cliente. Todos os modelos anteriores do MR poderiam fazer isso, mas o
MR ia além, pois o MR permitia identificar onde o cliente mora; as compras que ele fez, e com as
compras era possível ter acesso a data que a compra foi feira e qual foi a influência que ela teve no
estoque, e caso o estoque fique baixo, posso ter uma relação diretamente com meu fornecedor.

8
Linguagem de Exploração “Structured English Query Language”
Uma das linguagens de exploração mais utilizadas foi o Structured English Query
Language(SEQUEL), porém, com o passar dos anos, esse nome foi mudado para Structured Query
Language, ou, mais comumente conhecida como SQL. O SQL é uma linguagem de consulta, onde o
programador pode dar instruções/comandos ao ambiente do banco de dados e o banco de dados vai
lhe retornar uma query—resposta a uma solicitação.
Primeiramente, a ideia inicial era que o SQL deveria ser uma linguagem universal, ou seja, o
mundo todo deveria aderir a uma única linguagem SQL e que todos os bancos de dados do mundo
suportariam comandos SQL. Entretanto, cada fabricante resolveu dar um toque pessoal ao SQL,
assim surgindo em várias SQL pelo mundo, resultando num mercado confuso com várias
linguagens.

Ideia inicial:

Um
Umúnico
únicoSQL
SQLno
nomundo
mundo
inteiro.
inteiro.
SQL

Resultado final:

Vários SQL, gerando um

SQL mercado confuso com tantas

SQL SQL linguagens.

SQL SQL SQL

Para resolver essa despadronização de tantas linguagens, vieram os órgãos de padronização,

como ANSI e ISO, para padronizá-los. Por isso que um SQL compatível com ANSI e ISO, significa
que esse SQL é padronizado. E então, foi surgindo diversos bancos de dados como o Oracle; o
próprio banco de dados da IBM, o Db2; dBASE(Não mais utilizado atualmente); e Microsoft SQL

9
Server. Porém todas esses bancos de dados são pagos. Já em relação a banco de dados gratuitos,
existe o MySQL; MariaDB, criada por partes dos programadores do MySQL; FireBird;
PostgreSQL.

10
MySQL
Tudo começou em 1994, na Suécia, onde dois caras: Michael Widenius, também conhecido
como Molti; e David Axmark, resolveram criar um modelo gratuito de banco de dados baseado no
MR e livre, tornando-se GPL. E, ao longo dos anos, o MySQL veio se popularizando e se
consolidando até se tornar um dos maiores bancos de dados. E em 2007, ele foi comprado pela Sun
Microsystems que, posteriormente, a Sun Microsystems é comprada pela Oracle em 2009; assim,
assumindo a posse do MySQL. E então, Michael e David, vendo que o MySQL pertence a Oracle,
que já possuía um banco de dados pago muito conhecido e agora possuía também o MySQL,
resolvem criar outro banco de dados como um fork do código aberto do MySQL, o MariaDB.
Entretanto o MariaDB não evoluiu tanto quanto o MySQL no mercado.
O MySQL é tão famoso que muitas empresas grandes o utilizam, como a NASA, Google,
Wikipédia, Adobe, Cisco, Ebay, operadoras de telefone(Tim, Oi, Claro e Vivo), Bradesco, e até
mesmo as Forças Armadas do Brasil.

O MySQL tem uma linguagem tão potente que ele segue todos os princípios de bancos de dados
e ainda possui comandos específicos para determinadas situações, chamadas de categorias:
• DDL(Definição): É onde o programador vai definir o banco de dados, criar tabelas, alterar o
banco de dados etc., ou seja, o DDL envolve os comandos de definição da estrutura da base
de dados que é mantida pelo MySQL pela porção DDL;
• DML(Manipulação): Onde é possível incluir, excluir dados, manipular dados de qualquer
maneira e até mesmo alterar sua composição;
• DQL(Solicitações): Permite fazer qualquer solicitação de dados;
• DCL(Controle): Permite que usuários podem acessar o banco e que tipo de acesso eles terão,
que tipo de comandos ele poderá executar, etc;
• DTL(Transações): Transação é qualquer solicitação que pode ser feita a um banco de dados
e ele vai lhe atender da melhor maneira possível seguindo os princípios da DICA—
Características de uma boa transação—:
◦ Durabilidade: Todo dado que é colocado, alterado ou manipulado deve permanecer
durável enquanto estiver no banco de dados;
◦ Isolamento: Se houver duas transações executadas ao mesmo tempo, elas devem ocorrer
sem interferir uma com a outra; devem ser isoladas;
◦ Consistência: Toda transação deve levar o banco de dados de um estado consistente para
outro estado consistente. Se tudo estava ok antes, tudo deve estar ok depois;
◦ Atomicidade: Trata que toda transação deve ser atômica, ou tudo acontece, ou nada
acontece, ou tudo dá certo, ou o banco de dados voltará a um estado anteriormente
consistente.

11
Iniciando o wampserver com MySQL
1.º. Instale o WampServer e o MySQL Workbench;
2.º. Execute o Wamp;
3.º. Abra a barra de tarefas no ^ e veja se há um ‘W’ verde, se estiver tudo certo, se não, tente
fechar e executar o Wamp novamente;
4.º. Abra o MySQL Workbench;
5.º. Abra o servidor local;
6.º. Já pode começar a fazer os scripts.

12
Capítulo II - Criando o primeiro banco de dados
Entendendo um banco de dados
Digamos que exista uma pessoa chamada Godofredo, cuja idade é de 32 anos, sexo masculino,
peso de 78.5 kg, altura de 1.83 m, e é brasileiro:

Nome: Godofredo
Idade: 32
Gênero: Masculino
Peso: 78.5 kg
Altura: 1.83 m
Nacionalidade: Brasil

Todas essas características são normais e que todo mundo tem, até mesmo a namorada de
Godofredo:

Nome: Dolores
Idade: 30
Gênero: Feminino
Peso: 52.3 kg
Altura: 1.65 m
Nacionalidade: México

E então, alguns anos se passaram e eles tiveram uma filha:

Nome: Godolores
Idade: 3
Gênero: Feminino
Peso: 25.8 kg
Altura: 0.89 m
Nacionalidade: EUA

Analisando cada uma das três pessoas: Godofredo, Dolores, e Godolores, é possível notar algo
em comum: características. Onde cada característica é comum em todas essas pessoas, as tornando-
as instâncias, mas com valores diferentes, as diferenciando umas das outras. E esse é o objetivo do
banco de dados: registrar instâncias separadas de coisas de característica semelhantes.
E se analisarmos ainda mais, é notável que podemos cadastrar qualquer tipo de pessoa, pois
todas têm as mesmas característica, mas não os mesmos valores.

Digamos também que podemos colocar todas essas pessoas em um contêiner específico para
apenas pessoas chamado também de pessoas, e todas as instâncias que estiverem dentro desse
contêiner vão receber essas características:

Nome
Idade
Sexo

13
Peso
Altura
Nacionalidade

E toda vez que uma nova pessoa for cadastrada no banco de dados ela será enviada para esse
contêiner. Vale ressaltar que não é obrigatório o cadastro de todas as características, podem ser
opcionais o cadastro dessas características, como a nacionalidade do banco de dados citado
anteriormente.
Podemos também criar contêiner diferentes para coisas diferentes. Ex.: podemos criar um
contêiner chamado jogos, onde cadastraremos todas as características de jogos. Pessoas e jogos são
coisas diferentes, por isso recebem características diferentes, e por isso precisam estar em contêiner
diferentes. E então, no contêiner jogos, vamos adicionar vários jogos junto com algumas de suas
características como: título, fabricante, gênero, plataforma, etc.
Resumindo a base de banco de dados:
Pessoas:
Jogos:

Contêiner: pessoas

Contêiner: jogos

• Agrupar coisas de características semelhantes:

Contêiner: pessoas

Contêiner: jogos

• Separar coisas de características diferentes:

• Agrupar coisas diferentes em diferentes contêiner para que apenas exista coisas com

14
Contêiner: jogos
Contêiner: pessoas
 E, para finalizar, é possível adicionar todos esses contêineres em um navio. E todas essas coisas
sim, existem na teoria dos bancos de dados, porém com outros nomes já conhecidos:

Figura 2: Captura de tela tirado de uma aula do curso de MySQL do Curso

em Vídeo.

• Banco de dados: São coleções de dados de características separadas mas que estão
organizadas em locais específicos;
• Tabelas: Os locais específicos citados anteriormente são as tabelas, que guardam dados
de coisas com características semelhantes. É possível existir várias tabelas em um único
banco de dados;
• Registros: São os dados registrados nas tabelas.

Resumindo: Banco de dados são conjuntos de tabelas, tabelas são conjuntos de registros; e
registros possuem campos, valores:

15
 Banco de dados
Tabela 1 Tabela 2

Registro 3
Registro 1
Campo Registro 4

Registro 2 Campo
Campo Registro 5

Campo Campo

16
Criando o banco de dados no MySQL Workbench

Criar banco de dados

Criar uma tabela

17
Tipos Primitivos

Como os dados serão armazenados no disco, o tipo dele importa muito pro banco de dados
por isso temos os Tipos primitivos:
• Numéricos:
◦ Inteiro:
A diferença dos tipos primitivos são, na maioria das
▪ TinyInt;
vezes, pela quantidade de bytes que o campo vai
▪ SmallInt;
armazenar e no tamanho do valor armazenado. Ex.:
▪ Int;
TinyInt: 30; BigInt: [Link].000.000.000
▪ MediumInt;
▪ BigInt.
◦ Real:
▪ Decimal;
▪ Float;
▪ Double;
▪ Real.
◦ Lógico(yes/no; false/true; 0/1):
▪ Bit;
▪ Boolean.
• Data/Tempo:
◦ Date: data;
◦ DateTime: datas, horas, e informações a mais;
◦ TimeStamp: datas, horas, e informações a mais;
◦ Time: Somente hora;
◦ Year: Somente ano.
• Literal:
◦ Caractere:
▪ Char: Fixo; Se um nome tiver o máximo de 30 letras, o nome preencherá os 30
caracteres, se não preencher tudo o resto será preenchido com espaços;
▪ VarChar: Variante; Diferente do Char, o banco vai guardar apenas os caracteres que
estiverem em uso.
◦ Texto:
Caractere x texto = Caractere é para
▪ TinyText;
pequenas palavras, Texto é para pequenos a
▪ Text;
longos textos.
▪ MediumText;
▪ LongText.
◦ Binário: O tipo blob permite guardar qualquer coisa
▪ TinyBlob; em binário, como imagens, embora não seja
▪ Blob; recomendado guardar imagens em um BD.
▪ MediumBlob;
▪ LongBlob.
◦ Coleção: Enum e Set: São tipos onde é possível
▪ Enum; configurar quais são os valores permitidos,
▪ Set. e ele só vai aceitar esses valores nos
O tipo Espacial permite guardar
cadastros.
• Espacial:
informações sobre volumétricos.
◦ Geometry;
◦ Point;
◦ Polygon;
◦ MultyPolygon.

18
Visualizar a estrutura de uma tabela

Abrir um banco de dados

Visualizar os bancos de dados

Visualizar qual bando de dados está aberto no Terminal

Visualizar tabelas

Deletar um banco de dados

19
Criação de um banco de dados na prática
1.

2.

3.

Obs.: Vamos mudar esse campo idade futuramente!

20
Melhorando estrutura do banco de dados
Como visto anteriormente, é possível criar um banco de dados usando o comando create
database [nome do banco de dados];, porém há uma forma melhorada de criá-lo; definindo que tipo
de dados serão inseridos já no comando de criação do banco de dados: criar um banco de dados que
aceite caracteres acentuados—á, à, í…—, pois, as vezes, o banco de dados salva seus dados em um
utf que não aceita caracteres acentuados.

Para criar um banco de dados com um utf definido, é necessário adicionar alguns parâmetros no
comando de criação de banco de dados; e esses parâmetros são chamados de Constraits. A primeira
é default character set utf8, e a segunda é uma collation—também serve como definição de
caracteres assim como a definição do utf8—default collate utf8_general_ci. E então, o código de
criação de banco de dados fica assim:

Agora, com um banco de dados melhorado, resta também melhorar as tabelas; que tinham um
problema de que poderia ser cadastrado mais de uma pessoa com o mesmo nome, idade, gênero,
peso, altura, e nacionalidade, pois é possível, mesmo que difícil, achar mais de uma pessoa com as
mesmas características. E, para resolver esse problema, é necessário criar uma chave primária(key)
—um atributo que vai diferenciar uma pessoa de outra, um identificador único.
Também há mais dois problemas:
1. O atributo de idade: pois não é uma boa prática adicionar um atributo de idade sabendo
que ela é alterada anualmente. Uma solução para esse problema é substituir esse atributo
de idade por um de nascimento, onde o seu valor será date, assim o sistema pode calcular
a idade do usuário de acordo com o dia de ele nasceu.
2. O atributo de gênero: onde é recomendado salvar o gênero do usuário utilizando o tipo
primitivo de coleção enum, que não vai obrigar o usuário a ter que cadastrar seu gênero.

21
Tabela atualizada

Pontos a se notar da modificação do banco de dados

1. O ‘not null’ no atributo de nome: esse ‘not null’ simplesmente significa que o valor de nome
nunca será nulo;
2. O ‘enum(‘M’, ‘F’, ‘O’) no atributo de sexo: Esse enum significa que o gênero do usuário
apenas será cadastrado se ele atribuir um valor ‘M’, ‘F’, ou ‘O’. Nesse contexto, ‘M’, ‘F’, e
‘O’, significam Masculino, Feminino, e Outro, respectivamente;
3. O ‘decimal(5,2)’ e o ‘decimal(3,2)’ nos atributos de peso e altura, respectivamente: Eles
nada mais que separam o valor em bits. No peso—(5,2)—, o valor do peso terá 5 bits ou
espaços no disco, enquanto desses cinco números, dois deles estarão após uma vírgula.
Segue um exemplo abaixo:

1 0 2 , 5 6 kg.

O mesmo ocorre na altura—(3,2)—, onde dos três números, dois deles estarão após a
vírgula. Veja o exemplo abaixo:

1 , 8 2 m.

4. A adição da Constrait ‘Default’ no atributo de nacionalidade: O uso dessa Constrait significa

que o atributo por padrão receberá o valor ‘Brasil’, e será redefinida se o usuário cadastrar
sua nacionalidade; assim sobrescrevendo o valor padrão;
5. Atributo id e suas constraits: Para se resolver o problema de repetição e a dificuldade de
identificação de pessoas com mesmos valores é necessário criar um id(identificador) para
identificar um usuário em específico. Já as constraits ‘not null’ e ‘auto_increment’
significam que o valor nunca será nulo, será obrigatório; e ele irá receber valor
automaticamente, respectivamente;
6. primary key(id): Essa linha significa que o tabela irá denominar o ‘id’ como chave primária
—identificador—. Um exemplo real de chaves primárias são matrículas de estudantes em
uma universidade, onde não pode haver dois estudantes com a mesma matrícula; ou até
mesmo um CPF, onde apenas uma pessoa pode ter apenas um CPF;

22
7. Observação: Em alguns tutoriais da internet, as pessoas podem colocar o nome dos atributos
e das tabelas dentro de crases(`), possibilitando colocar os nomes dos atributos com
acentuação; embora não seja recomendado.

23
Inserindo Dados na Tabela(INSERT INTO)
Agora, com os conhecimentos de criação de bancos de dados e criação de tabelas, agora é
possível aprender como inserir dados nas tabelas do banco de dados.
Com isso em mente, vamos revisar o cadastro do usuário Godofredo, segue a tabela de seus
dados abaixo:
nome Godofredo
nascimento 1984-12-30¹
sexo M²
peso 78.5
altura 1.83
nacionalidade Brasil

1. O nosso campo de idade virou nascimento; e com isso resolvemos o problema anterior de ter
que mudar a idade do usuário anualmente. E agora, o valor do campo de nascimento se torna
[ano]-[mês]-[dia];
2. Com o tipo primitivo enum o valor do campo de gênero só poderá ser preenchido com ‘M’,
‘F’, ou ‘O’.

Vale relembrar que o SQL é separado por categorias, e até agora apenas usamos uma categoria, a
DDL(Data Definition Language), onde definimos a estrutura do nosso banco de dados com os
comandos de:

• Criar banco de dados:

• Criar tabelas:

Agora, para inserir dados no banco de dados, vamos utilizar a categoria DML(Data Manipulation
Language), onde vamos manipular os dados do banco de dados. Para isso vamos aprender por
partes:

1.º. Vamos criar uma lista:

24
 2.º. Agora vamos adicionar os valores que vamos inserir na tabela:

3.º. O próximo passo é informar pro banco de dados que vamos inserir esses valores na tabela de
pessoas:
insert into =
“inserir em”;
values =
“valores”

Antes de executar esse código, vamos relembrar que nós, ao criar a tabela pessoas(pág. 12),
informamos que o id tem uma constrait de auto_increment, ou seja, ele se receberá um valor
automaticamente. Com isso em mente, não é necessário especificar o id. Veja abaixo:

Agora sim, executando o código, os valores serão cadastrados na tabela pessoas, e para poder
visualizar, utilizamos o comando abaixo:

Onde, o banco de dados vai mostrar tudo(*) o que estiver na tabela pessoas:

Também é possível cadastrar mais pessoas no banco de dados, como a Maria:

Também há outro ponto importante: o uso de constraits default no cadastro de pessoas. Podemos

25
utilizar essas constraits para substituir o id e a nacionalidade para default, o próprio id e Brasil por
padrão, respectivamente. Segue o código abaixo:

Vale ressaltar que, se a ordem dos valores dos campos for a mesma que a ordem dos atributos da
tabela, não é necessário informar os campos no início do código. Segue um exemplo:

Então, podemos simplificar dessa forma:

E, também há uma forma de inserir várias pessoas ao mesmo tempo apenas repetindo os valores
em linhas abaixo, veja:

26
27
Alterando a Estrutura da Tabela(ALTER TABLE e DROP TABLE)
Adicionando e Removendo uma Coluna
Primeiramente, antes de aprender como adicionar uma nova coluna na tabela, é necessário saber
que cada campo da tabela é chamada de coluna, como os campos nome, idade, etc., que criamos
anteriormente. E para se criar uma nova coluna, é necessário usar o comando alter table, que
significa “alterar tabela”.
Sabendo disso, segue o código para adicionar uma nova coluna em uma tabela:

Um exemplo real de como adicionar uma nova coluna é:

Obs.: Sempre é possível
visualizar os campos das
tabelas com o comando:
describe [nome da tabela];,
Visualize melhor: ou sua forma reduzida: desc
[nome da tabela];, já para
visualizar os usuários
usamos select * from [nome
da tabela];

Você viu como o campo de profissao foi criado abaixo de todas as outras? Caso você queria criar
uma coluna depois de algum campo em específico por exemplo, é necessário remover o campo
profissao que já criamos e usar a constrait after nome_do_campo. Veja um exemplo abaixo:

Agora veja abaixo um exemplo real, onde será criada o campo profissao depois(after) do campo
nome:

Agora visualize as colunas:

28
 Mas, como foi que foi deletada o campo profissao quando ele estava por último?

Para remover uma coluna, utilizamos o comando alter table com o parâmetro drop column. Veja
abaixo como é:

Veja um exemplo prático(que foi usado para deletar o campo profissao anteriormente) abaixo:

Agora visualize melhor:

Viu que agora o campo profissao foi deletado? Agora você entende como que o campo foi
deletado antes de criarmos o novo campo profissao logo após o campo nome.

Também é possível criar uma coluna que sua posição seja a primeira. E para isso, utilizamos a
constrait first, ao criar uma nova coluna. Veja um exemplo com not null abaixo:

Visualize melhor:

29
Modificando nova Coluna
Para modificar uma coluna, também é usado o comando alter table, mas dessa vez há alguns
parâmetros diferentes:
Obs.: Esses erros apenas aparecem pois
estamos utilizando ‘[nome da tabela]’ como
exemplo, esse erro irá sumir logo logo.
Segue abaixo um exemplo real:

Entenda alguns pontos:

• modify column: Essas constraits significam que vou modificar a coluna;
• varchar(20): Isso significa que eu sobrescrevi o tipo primitivo que antes era de 10 bits, o que
era muito pouco;
• not null default ‘’: Essas constraits significam que o campo profissao nunca será nulo, e que
o valor padrão sempre será ‘’—vazio.

Para visualizar se a modificação deu certo, é necessário usar os comandos desc pessoas;, para
ver se o campo profissao ainda aceita o valor null; e depois usar o comando select * from pessoas;,
para visualizar o que aconteceu com o campo profissao das pessoas da nossa tabela. Veja abaixo:

• desc pessoas;

• select * from pessoas;

Obs.: Se o comando fosse apenas:

ao executá-lo o sistema apresentaria um erro; porque o comando iria entrar em conflito com o

30
campo. Vamos entender melhor isso:

Na visualização acima, é possível perceber que o valor do campo profissao de todos os usuários
é null.

Já esse comando modifica o campo profissao e informa que ele não pode ser null. O que entra
em conflito é: Antes os valores de profissao já eram null, mas com o novo comando estamos
informando que o valor não pode mais ser null. Com isso, o sistema não sabe o que fazer. E, para se
resolver isso, foi utilizado o a constrait default ‘’, para informar pro sistema que o padrão de
profissao é ‘’(vazio). Assim, os valores do campo profissao dos usuários ficam assim:

Obs.: O campo
de profissao das
pessoas foi
preenchida com o
padrão ‘’(vazio).

Obs.: O campo
de profissao já
não aceita mais
null.

Renomeando uma Coluna

Para mudar o nome de um campo, é necessário utilizar o alter table com o parâmetro change, além
de ter que praticamente reescrever todo o campo, se não as constrait não serão usadas. Veja a
sintaxe abaixo:

31
Agora veja o exemplo de mudar o nome do campo profissao para prof:

Visualize:

32
Renomeando uma Tabela
Também é possível renomear tabelas, também utilizando o alter table, mas dessa vez com o
parâmetro rename to. Veja a sintaxe:

Agora vamos renomear a nossa tabela pessoas para funcionarios:

Visualize os schemas agora:

Obs.: Tome cuidado para não continuar usando comandos com o nome da tabela antiga
‘pessoas’; lembre-se que a renomeamos para ‘funcionarios’.

33
Mais uma Tabela...
Existem alguns parâmetros bem interessantes do MySQL, alguns deles são:
• if not exists: Fazer outra coisa se não existir(if not exists);
• if exists: Fazer alguma coisa se existir(if exists).

Que tal tentarmos criar uma tabela usando o if not exists?

Vamos entender algumas coisas:

• create table if not exists cursos: Esse comando vai criar a tabela cursos caso ela não exista;
• Constrait unique: Ela não vai permitir que haja um outro curso com o mesmo nome. Aviso:
Lembre-se que ela não é uma primary key!!! Mas ela servirá como uma caso você não
informe uma primary key!
• Constrait unsigned: Ela vai impedir que o valor numérico tenha sinal, ou seja, ele não
poderá ser negativo(-x).

Vish, esquecemos de adicionar a nossa primary key. Vamos criá-la agora sem ter que deletar a
tabela e refazê-la?

• Primeiro vamos adicionar uma coluna com o valor do da primary key:

Visualize:

• Agora, vamos adicionar o idcurso como primary key:

Visualize:

34
35
Apagando Tabelas

Segue a sintaxe do comando para se deletar uma tabela:

Você também pode utilizar o parâmetro if exists, veja:

36
Manipulando Linhas(UPDATE, DELETE e TRUNCATE)
Em alguns livros técnicos, os registros também podem ser chamados de linhas ou até mesmo
tuplas. Registro = tupla = linha.

Vale destacar que o resultado de uma consulta como select e desc são chamadas de result set.

Para aprender a manipular linhas, vamos adicionar alguns registros na tabela de cursos que
criamos na aula 6. Siga o código abaixo:

Podemos também visualizar o result set usando a instrução select * from cursos, veja abaixo o
resultado:

Pronto, agora que adicionamos os registros, podemos manipular as linhas.

37
Sobrescrevendo valores de registros
Para sobrescrever os valores de registros utilizamos a instrução update. Veja a sintaxe abaixo:

Veja essa tabela simplificada com as linhas que vamos modificar os valores em vermelho, e
vamos utilizar os valores em verde como auxílio:

idcurso nome carga ano

1 HTML4 40 2014
4 PGP 40 2010
5 Jarva 10 2000

Ficou difícil de entender? Vamos ver um exemplo prático utilizando os registros recém
adicionados na tabela cursos:

E então, a linha que tinha o nome HTML4 agora virou HTML5, veja o result set:

Vamos entender ainda mais a instrução update. Se traduzirmos o comando update que acabamos
de executar, ficaria assim:

Atualize(update) cursos,
configurando(set) o nome para HTML5
onde(where) o idcurso for 1.

Vale destacar que é possível modificar duas colunas da mesma linha com uma única instrução,
onde podemos colocar uma vírgula no final da linha do set, e colocar outro valor para ser
sobrescrito. Com isso, vamos modificar o nome e o ano do campo cujo idcurso é 4:

Agora veja o result set:

38
 Agora, para editar a linha do idcurso 5, vamos ver algumas coisas novas. Saiba, que, a instrução
update é muito perigosa, pois existe a possibilidade/risco de, sem utilizar a chave primária como
auxílio, ocorrer um problema é a instrução sobrescreva várias linhas ao mesmo tempo. Ex.:
Modificar o nome de todos os cursos que tenham 40 horas para ‘Python’. E, para não correr o risco
desse problema, é necessário utilizarmos um parâmetro especial para limitar o efeito do comando
para um número específico de linhas. Veja um exemplo abaixo com a linha do idcurso 5:

Também é importante lembrar que não importa a ordem do carga ou ano, a instrução vai ser
executada da mesma forma. E esse limit usado na linha 4 significa que esse comando só vai afetar
um registro. Agora veja o result set:

Agora, vamos por em prática o problema de não limitar o número de linhas afetadas pela
instrução update:

• Temos esses valores aqui da nossa tabela:

• Agora vamos atualizar o ano e a carga de todos os cursos que sejam de 2018:

• Geralmente, ao executar esse código, o sistema do MySQL Workbench lhe informará um

erro: ‘Error Code: 1175. You are using safe update mode and you tried to update a table
without a WHERE that uses a KEY column. To disable safe mode, toggle the option in
Preferences -> SQL Editor and reconnect’. E esse erro se trata de um sistema de segurança
do próprio Workbench para impedir que a instrução update cause grandes estragos. Podemos
desativar esse sistema de segurança nas configurações do MySQL Workbench. Siga os
passos abaixo:
1.º. Clique no botão edit para abrir o menu:

39
2.º. Clique na opção de preferências:

3.º. Clique na opção de SQL Editor:

40
 4.º. Scrolle para baixo até encontrar a opção do “Safe Updates”, depois, desative-a e
clique em okay:

5.º. Depois, clique no botão para reconectar:

• Executando o código, temos esse result set:

Vamos entender o problema real de um update não seguro: Digamos que um banco tem um
banco de dados com as dívidas de todos os seus 2.000.000 usuários—clientes. Então, um
funcionário executa um update errado e, sem querer, todos os usuários estão com uma dívida de
R$9.999.999.

41
 Por isso, é de suma importância que tenhamos um backup do nosso banco de dados, justamente
para que não ocorram problemas futuros.
Mas agora, que temos o ‘Safe Update’ desativado, vamos ver o que acontece se tentarmos mudar
todos os cursos que tenham o ano 2050 para o ano de 2018 e carga 0, mas com o limit 1:

Vejamos o result set:

Podemos ver que, com o limit 1, o código apenas afetou uma linha da nossa tabela. Uma dica:
Evite utilizar o update no seu banco de dados principal sem backup, mas se for utilizar, use o ‘safe
update’.

Agora, com todas essas alterações feitas anteriormente, temos essa tabela:

Porém temos um problema, essas últimas 3 linhas não são necessárias para nós. Podemos as
remover.

42
Removendo uma Linha
Para se deletar uma linha de uma tabela, é necessário utilizar um comando delete, muito parecido
dom o update visto anteriormente; mas no delete, não utilizamos o set, apenas o where; para
especificar onde iremos deletar a linha. Veja a sintaxe abaixo:

Veja um exemplo prático onde vamos deletar a linha do idcurso 8:

Veja agora o result set:

CUIDADO: NÃO HÁ CTRL + Z; NÃO HÁ COMO REVERTER O DELETE. SE VOCÊ

ESQUECER DO WHERE, TODAS AS LINHAS SERÃO DELETADAS!!!!!!!

Também podemos deletar várias linhas ao mesmo tempo, também com o ‘safe update’
desativado. Com isso em mente, vamos deletar as duas linhas de cursos do ano de 2050:

Result set:

43
Removendo TODAS as Linhas
Além do problema do delet sem o where, que deletava todas as linhas da tabela; temos um
comando específico para remover todas as linhas de uma tabela, o truncate. Veja a sintaxe abaixo:

Agora, vamos deletar todas as linhas da nossa tabela cursos:

Result set:

Agora, vamos revisar a classificação dos comandos que aprendemos até aqui:

DDL DML
(Data Definition Language) (Data Manipulation Language)

create database insert into

create table update
alter table delete
drop table truncate
drop database

44
Capítulo III - Gerenciando Cópias de Segurança MySQL
Preparando ambiente
Relembrando que deletamos todos os dados da tabela cursos na aula passada usando o comando
de truncate, agora vamos adicionar alguns dados para podermos fazer um backup do nosso banco
de dados com nossas tabelas de cursos e funcionarios. Veja os registros que vamos adicionar a
tabela:

45
Criando um dump
Agora sim, podemos aprender a fazer backups; para isso, siga os passos abaixo
1.º. Clique na opção Server:

2.º. Clique em Data Export:

3.º. Selecione os schemas/banco de dados que você queira exportar:

46
4.º. Após selecioná-lo, clique sobre ele para selecionar quais tabelas você quer exportar junto
com o schema:

Obs.: A(O) cópia/backup de um banco de dados tem o nome de dump.

5.º. Você pode ver os tipos de exportação do Dump clicando aqui:

47
6.º. Aqui, nós temos três opções de exportações: Dump Structure and Data, Dump Data Only e
Dump Structure Only:

I. Dump Structure and Data: Exportação da estrutura(tabelas/Structure) e

dados(registros/Data);
II. Dump Data Only: Exportação de apenas os dados(registros/Data);
III. Dump Structure Only: Exportação de apenas da estrutura(tabelas/Structure).

Dessa vez, vamos exportar os dados e estrutura; então vamos usar o Dump Structure and
Data.

7.º. Depois de decidir o que será exportado, é necessário decidir o tipo de exportação:

48
 I. Export to Dump Project Folder: O nosso dump será exportado em uma pasta específica;
II. Export to Self-Contained File: O nosso dumo será exportado em um arquivo único.

Vamos criar um dump de arquivo único, ou seja, Export to Self-Contained File.

8.º. Também há uma opção de Include Create Schema, onde o próprio dump vai criar o banco de
dados, sem precisar que nós o criamos manualmente para depois importarmos um dump:

9.º. Com tudo isso, podemos criar nosso dump clicando no botão de Start Export:

49
 Ao clicar em Start Export, o MySQL vai exigir que você insira a senha do seu usuário
admin de seu servidor.

10.º. Com isso, se tudo der certo, o MySQL vai lhe mostrar essa tela de sucesso.

50
Importando um Dump
Agora que temos um backup/dump, podemos remover nosso banco de dados do Workbench e
importar o nosso dump. Primeiro vamos remover nosso banco de dados com o comando drop
database. Veja abaixo:

Após isso, podemos importar nosso dump seguindo esses passos:

1.º. Clique na opção de Server:

2.º. Clique na opção Data Import:

3.º. Agora, você vai decidir o que você vai importar, uma pasta—caso o dump foi criado numa
pasta—, ou um arquivo único—caso o dumo foi criado como um arquivo único. E depois,
selecione o seu dump:

51
4.º. Agora, com o dump selecionado, você pode clicar no botão de Start Import:

Em seguida, o Workbench vai lhe pedir novamente a senha do usuário admin do servidor.

5.º. Então, com essa tela de sucesso, você pode atualizar os schemas e tudo estará funcionando
normalmente.

52
 E então, a importação do nosso dump foi realizada com sucesso, veja:

Agora, você pode usar o use cadastro; para entrar no banco de dados, usar o show tables; para
visualizar as tabelas, desc cursos; e desc funcionarios; para visualizar os campos das tabelas cursos
e funcionarios, e, por fim, select * from funcionarios; e select * from cursos; para ver os registros
das tabelas funcionarios e cursos. Vamos ver o result set de cada um deles abaixo:

• show tables;

• desc cursos;

• desc funcionarios;

53
• select * from funcionarios;

• select * from cursos;

Isso comprova que a exportação e importação do nosso dump foi realizada com sucesso!

54
Capítulo IV – PHPMyAdmin
O PHPMyAdmin, assim como o MySQL e o próprio terminal do PC, é uma ferramenta usada
trabalhar com banco de dados.
Para se acessar o PHPMyAdmin, é necessário ativar o servidor local com o Wamp e depois
acessar ‘localhost/phpmyadmin’ no seu navegador. Então, é necessário logar o seu usuário e senha,
depois disso, você terá acesso aos bancos de dados do seu servidor. E uma grande vantagem do
PHPMyAdmin é que você pode editar o banco de dados de uma forma mais visual e interativa, ao
invés de código puro como o terminal e código e interface com o MySQL Workbench.

Modificando dados no PHPMyAdmin

Para editar um registro no phpmyadmin, devemos entrar na nossa tabela e clicar no botão de
editar o dado. Vamos editar o peso do nosso usuário João, por exemplo:
1. Vamos clicar na tabela de funcionários:

2. Note que há um lápis na mesma linha que nosso usuário João, clique nesse lápis para editar:

3. Clicando no lápis se abre essa tela de edição, onde podemos editar os dados de João. Veja
que há uma seção de peso, onde vamos editar o valor para 55.20. Depois, clique no botão de
executar:

55
4. Note também que apareceu uma linha verde informando que uma linha foi afetada, e
também há o código SQL que aprendemos anteriormente. Esse código, como já vimos antes,
modifica uma linha. Podemos notar também que o valor do peso de João foi atualizado:

56
Criar um novo banco de dados
Para criar um novo banco de dados no PHPMyAdmin, siga os passos abaixo:

1.º. Você precisa estar nessa página do PHPMyAdmin; caso não esteja, clique no ícone da casa:

2.º. E então, clique no botão de ‘novo’:

3.º. Após clicar em ‘novo’, você pode escolher o nome do novo banco de dados e até a Collation
—parâmetro para incluir caracteres especiais—. E, após isso, clique no botão de ‘criar’:

57
4.º. Logo após ter criado o banco de dados, o PHPMyAdmin irá lhe perguntar o nome de uma
tabela a ser criada e a quantidade de colunas(campos). Vamos criar uma tabela chamada
‘amigos’ e com três colunas:

5.º. Com essa página, você pode criar campos a vontade assim como no MySQL Workbench:

6.º. Após criar os campos, eles ficam visíveis:

58
 Você também pode alterar os campos no botão ‘Alterar’ ao lado do campo que deseja alterar.

Você também você pode criar outros campos nesse banco de dados com essa seção:

E como funciona o campo enum? Vamos criar um campo de ‘sexo’ com o tipo enum:

O ‘Tamanho/Valores’ recebe ‘M’, ‘F’, ‘O’ porque o campo só vai aceitar essas três letras.

59
 Também vale destacar que o PHPMyAdmin mostra o comando SQL usado para fazer a edição
que você fez.

60
Inserindo registros nas tabelas
Para inserir registros nas tabelas, siga os passos abaixo:

1.º. Com a tabela selecionada, clique na opção ‘Inserir’ no menu:

2.º. E então, você insere os registros e clica no botão de ‘executar’ no fim da página:

Obs.: Se você clicar no botão ‘executar’ dos usuários, apenas o usuário do botão irá ser inserido na
tabela.

3.º. E, após clicar no botão ‘Executar’, o PHPMyAdmin irá lhe transportar para essa página
onde você poderá visualizar o comando que o PHPMyAdmin usou para inserir os registros:

61
Agora, para visualizar os registros, você precisa clicar na aba de visualizar:

Agora veja:

Note que você também pode selecionar registros e removê-los:

62
63
Gerar um dumb(exportação) do banco de dados
Para gerar um dump do nosso banco de dados pelo PHPMyAdmin, siga os passos abaixo:

1.º. Clique na opção de ‘Exportar’ no menu enquanto você estiver na página home do banco de
dados:

2.º. Selecione o tipo de exportação entre rápida e personalizada:

Vamos utilizar a exportação personalizada.

3.º. Scrollando para baixo você poderá escolher qual banco de dados você quer gerar o dump:

64
4.º. Scrollando para baixo você poderá escolher se deseja já zipar o arquivo do banco de dados,
conferir a collation:

5.º. Outras especificações como incluir o create database, mostrar comentários…:

65
E então, podemos clicar no botão ‘Exportar’ e o navegador irá fazer o download do banco de
dados que acabamos de exportar.

66
Excluindo um banco de dados
Podemos também excluir banco de dados usando o PHPMyAdmin, veja os passos abaixo:

1.º. Na página home, clique na opção ‘Bancos de Dados’ no menu:

2.º. Selecione o seu banco de dados e clique em eliminar; e por fim, confirme:

67
Importando um banco de dados
Antes de aprender como importar um banco de dados no PHPMyAdmin, vamos deletar o banco
de dados que estávamos editando para depois importar outro. Delete o banco de dados, como
anteriormente aprendido, e faça o download do novo banco de dados. Lembre-se que esse dump
pertence ao curso de MySQL – Curso em Vídeo. Agora, siga os passos abaixo para importar um
banco de dados:

1.º. Na página ‘home’ do PHPMyAdmin, clique na opção de ‘Importar’ no menu:

2.º. Entrando na seção de importação, clique em escolher arquivo para importar o nosso dump:

3.º. Após selecionar o arquivo, scrolle para baixo e clique em importar:

68
4.º. E então, seu dump será importando com sucesso:

69
Capítulo V - Obtendo Dados das Tabelas
Vamos aprender vários parâmetros do comando select, para filtrar o resultado.
Primeiramente, vale destacar que o comando select * from cursos; vai nos mostrar tudo da
tabela. Digamos que tenhamos essa tabela cursos:

idcurso nome descricao carga totaulas ano

1 HTML5 … 40 37 2014
2 Algoritmos … 20 15 2014
3 Photoshop … 10 8 2014
4 PHP … 40 20 2015
5 Java … 40 29 2015
6 MySQL … 30 15 2016
7 Word … 40 30 2016
8 Sapateado … 40 30 2018
9 Cozinha Árabe … 40 30 2018
10 Youtuber … 5 2 2018

Caso utilizarmos o comando select * from cursos; o result set seria a tabela acima!

70
Ordenação Crescente e Decrescente
Primeiramente, é importante saber que o comando select * from cursos; mostra os registros na
ordem do idcurso—chave primária. Para termos um result set com o nome dos cursos em ordem
crescente, é preciso adicionar o parâmetro order by nome, ou ainda adicionando o asc—versão
encurtada da palavra ascendent(crescente) do inglês— depois do nome, veja o código abaixo:

ou

Com isso, nossa tabela ordenada assim:

Também é possível ordenar os nomes em ordem decrescente, e para isso, adicionamos a palavra
desc—versão encurtada da palavra descendent(decrescente) do inglês após o order by nome. Veja:

Com isso, nossa tabela fica ordenada da seguinte forma:

Aviso: Lembrando que o desc do comando select é diferente do desc do comando do desc

71
nome_da_tabela. Isso porque o desc do select significa descendent(decrescente) do inglês, enquanto
no desc nome_da_tabela o desc é uma versão encurtada da palavra describe(descrever) do inglês.

72
Selecionando Colunas
É possível ainda filtrar as colunas da nossa tabela para que apenas as colunas selecionadas sejam
mostradas no result set. Para isso, nós substituímos o asterisco(*) do comando select pelo nome das
colunas que queremos visualizar. Veja:

Essa substituição que fizemos significa que vamos selecionar(select) as colunas nome, carga e
ano da(from) tabela cursos, ordenadas por(order by) nome. E por isso, apenas as colunas nome,
carga e ano serão visualizadas. Veja abaixo:

Note que as colunas nome, carga e ano estão em verde pois são elas que serão visualizadas.

73
Múltipla Ordenação
Também é possível fazer uma ordenação múltipla dos registros de uma tabela usando o
parâmetro order by. Vamos pegar como exemplo o banco de dados que você baixou anteriormente.
Entre no banco de dados(use cadastro;) e depois digite o código abaixo:

O executando, teremos esse result set:

Note que primeiro o result set ordena os registros por ano, e depois ele ordena por nome em
ordem alfabética(crescente).

74
Selecionando Linhas
Where:
Também é possível filtrar linhas usando o comando select, e para isso utilizamos a clausula
where. Veja um exemplo abaixo:

Traduzindo: selecione(select) tudo(*) de(from) cursos onde(where) o ano é 2016(ano = 2016),

em ordem(order by) alfabética(nome).

Agora que você entendeu o código, veja o resultado:

Aviso: Lembrando que você ainda pode selecionar quais colunas serão mostradas substituindo o
asterisco(*) pelo nome das colunas!

Termo TEC 🤓
Query: Query é uma palavra do inglês que significa, ao
pé da letra, consulta. E em banco de dados, quando
estamos usando o comando select, estamos nada mais do
que fazendo uma consulta(query).

75
Operações Lógicas

Também é possível realizar operações lógicas com a clausula where. Como:

• Igual: =

• Menor: <

• Maior: >

• Menor ou maior: <>

76
• Menor ou igual: <=

• Maior ou igual: >=

• Diferente: !=

77
• Entre dois valores: campo between valor1 and valor2

• Dentro: in (‘valor_n1’, ‘valor_n’)

78
Operações Lógicas and(e) e or(ou):
E ainda é possível combinar as operações lógicas usando o and(e), onde o result set vai obedecer
as duas operações. E o or(ou), onde o result set vai obedecer pelo menos a uma operação. Entenda
melhor com o exemplo abaixo:

Digamos que você tenha dois amigos: Lucas e Maria. E você queremos chamar Lucas e Maria
para passear num parque.

Agora veja o exemplo do caso and:

Lucas Maria Você

✓ ✓ ✓
✓ ✕ ✕
✕ ✓ ✕
✕ ✕ ✕

Veja que, você só vai passear no parque se Lucas e(and) Maria quiserem ir. Se um deles ou os
dois não quiserem, você também não vai.

Agora veja o mesmo exemplo, mas do caso or:

Lucas Maria Você

✓ ✓ ✓
✓ ✕ ✓
✕ ✓ ✓
✕ ✕ ✕

Agora veja que, se Lucas ou(or) Maria quiserem ir, você vai. Se nenhum dos dois quiserem ir,
você não vai; e se os dois quiserem, você vai.

Agora, veja um exemplo real da nossa tabela:

Exemplo com and:

Isso significa que o result set só vai mostrar os registros que forem diferente de 2016 e maiores
que 2014. Veja o result set abaixo:

79
 Exemplo com or:

Isso significa que o result set só vai mostrar os anos que sejam de 2016 ou(or) 2018. Veja o result
set abaixo:

Dica: Se quiser entender melhor esses casos and e or,

pratique bastante!

80
Classificação do comando select
Vários livros e autores classificam o comando select como um comando da classe DML(Data
Manipulation Language-Linguagem de Manipulação de Dados), mas, nesse curso, vamos classificá-
lo em outro tipo de classificação: DQL(Data Query Language-Linguagem de Consulta de Dados).

DDL(Linguagem de Definição DML(Linguagem de DQL(Linguagem de Consulta

de Dados Manipulação de Dados) de Dados)
create database insert into select
create table update -
alter table delete -
drop table truncate -
drop database - -

81
Seleção por Nome
Para filtrar o result set para selecionar um nome específico é necessário utilizar o parâmetro
where do comando select. Veja o código abaixo:

Agora veja o result set:

82
Usando o Operador Like
Podemos ainda utilizar o operador like para filtrar todos os campos parecidos com o que foi
instruído. Veja a sintaxe abaixo:

Vejamos um exemplo real:

Isso significa que o comando vai selecionar(select) tudo(*) de cursos(from cursos) onde(where)
nome for parecido(like) com P e qualquer outra coisa(%). Vamos ver a execução desse código
acima:

Resumindo aquela parte do ‘P%’: O % nesse código é conhecido como um wildcard—carta

coringa—, onde podemos a utilizá-la para substituir nada ou algo(no nosso caso, o resto dos
caracteres. E o P na frente do % significa que o que vamos procurar começa com P e termina com
qualquer coisa.
Vale destacar também que não importa se o ‘p’ for maiúsculo ou minúsculo, o operador like é
sensível o bastante para incluir os dois modos, e, com o utf8, pode incluir até caracteres com
acentuação.

Também é possível utilizar o % antes de um caractere, vamos testar?

Vamos analisar o que aconteceu: como o % estava antes do caractere ‘a’, isso significa que o
nosso result set iria mostrar qualquer coisa que terminasse com o caractere ª

E também é possível utilizar o % antes e depois de um caractere, vamos ver o que acontece?

83
 Agora vamos entender esse grande result set: como definimos o like como ‘%a%’, isso significa
que pode ter qualquer coisa antes e depois do caractere ‘a’, ou seja, o result set irá mostrar todos os
curso que possuem pelo menos um caractere ‘a’.
Também é possível usar a constrait not nesse comando, implicando que vamos selecionar todos
os registros que não possuem o caractere ‘a’; veja abaixo:

Além do % do operador like, também temos o _(underline), que significa que a posição do
underline significa que é obrigatório existir um caractere; diferente do % que pode não existir nada.
Veja um exemplo abaixo:

Obs.: Existia um caractere na posição da underline, então o result set mostrou esses registros.

Podemos também filtrar nomes de pessoas usando esse operador. Vamos filtrar da tabela
‘gafanhotos’ todas as pessoas que possuem ‘Silva’ como sobrenome:

84
 Nesse caso, os % antes e depois são usados para informar que pode existir caracteres antes e
depois de ‘Silva’.
Mas, você notou algo estranho? O nome ‘Silvana’ não é um sobrenome. Para se resolver esse
problema há uma pequena mudança no código:

Essa mudança no código, com ‘%_Silva%’, significa que é obrigatório haver um caractere antes
de Silva, depois disso pode haver qualquer outra coisa; e isso quebra o problema com a Silvana,
pois não existe nenhum caractere antes do ‘Silva’ do nome ‘Silvana’. Porém se o nome da Silvana
fosse ‘Maria Silvana’, o erro iria permanecer, pois antes do ‘Silva’ haveria um caractere de espaço.

85
Distinguindo:
Também é possível distinguir registros iguais de uma tabela usando distinct. Veja a sintaxe
abaixo:

Veja o result set normal da tabela cursos para que você entenda corretamente:

Analise a coluna de carga, percebe que há vários cursos com cargas iguais? E que as cargas se
repetem? O distinct vai pegar esses valores iguais, como o ‘40’ que se repete várias vezes, e vai
mostrar apenas uma vez.
Não entendeu? Vamos fazer um exemplo prático distinguindo a carga dos cursos. Veja o código e
o result set abaixo:

Viu que os valores iguais não se repetiram? Isso é bem diferente do comando select carga from
cursos; que vai mostrar todas as cargas e não iria se preocupar com aquelas que se repetem. Veja o
result set abaixo:

86
 Vamos ver outro exemplo para que a informação fique mais clara. Tendo a tabela de ‘gafanhotos’
abaixo:

Podemos utilizar o distinct para distinguir os países e descobrir quais são as nacionalidades das
pessoas de uma maneira organizada e sem repetir dados. Veja o código e result set abaixo:

Agora veja a diferença entre o result set acima com o result set do comando select nacionalidade
from gafanhotos;, que não filtra as nacionalidades:

87
 Percebe que os valores se repetem? Essa é a diferença entre o comando com o distinct para o
mesmo comando mas sem o distinct.

88
Funções de Agregações:
As funções de agregações servem para selecionar ou totalizar alguma coisa. Veja as principais
funções de agregações abaixo:

• count:

A função count serve para contar campos das tabelas. Veja a sintaxe abaixo:

Ex.1: Agora vamos ver um exemplo onde vamos contar quantos cursos existem na tabela
‘cursos’:

Ex.2: Ainda é possível contar quantos cursos de 2018 existem na tabela ‘cursos’; veja:

• max:

A função max serve para contar qual é o maior registro dentre as colunas. Veja a sintaxe
abaixo:

Ex.1: Contar qual é o maior números de aulas que um curso tem na tabela ‘cursos’:

• min:

A função min serve para contar o menor valor de uma coluna. Veja a sintaxe abaixo:

Ex.1: Contar qual foi o mínimo de aulas dos cursos de 2016 da tabela ‘cursos’ e saber qual e
o nome do curso:

89
• sum:

A função sum serve para somar os valores das colunas. Veja a sintaxe abaixo:

Ex.1: Calcular a soma de todas as aulas da tabela ‘cursos’:

• avg:

A função avg serve para calcular a média dos valores de uma coluna. Veja a sintaxe abaixo:

Ex.1: Calcular a média das cargas dos cursos da tabela ‘cursos’:

90
Exercícios
01 – Digamos que você está trabalhando em uma empresa que gerencia bancos de dados, e seu
chefe lhe dá as seguintes instruções do que você tem que fazer na tabela ‘gafanhotos’ para que ele
possa fazer um relatório.

a. “Uma lista com todas as mulheres.”

b. “ Uma lista com os dados de todos aqueles que nasceram entre 01/01/2000 e 31/12/2015.”

c. “Uma lista com o nome de todos os homens que trabalham como Programadores.”

d. “Uma lista com os dados de todas as mulheres que nascera, no Brasil e que têm seu nome
iniciando com a letra J.”

e. “Uma lista com o nome e nacionalidade de todos os homens que têm Silva no nome, não
nasceram no Brasil e pesam menos de 100kg.”

f. “Qual é a maior altura entre os homens que moram no Brasil?”

g. “Qual é a média de peso das pessoas cadastradas?”

h. “Qual é o menor peso entre as mulheres que nasceram fora do Brasil e que nasceram entre
01/01/19990 e 31/12/2000?”

i. “Quantas mulheres têm mais de 1.90m de altura?”

91
Correção dos Exercícios
a.

b.

c.

d.

92
e.

f.

g.

h.

i.

93
Agrupando Registros
Diferente de distinguir, agrupar registros nada mais é do que juntar os registros que são iguais. E,
para isso, utilizamos o group by. Veja a sintaxe abaixo:

Ex.1: Agrupamento de cargas da tabela ‘cursos’:

Mas qual a diferença entre o distinct e o group by?

O distinct descarta os valores iguais e mostra apenas um deles. Ele mostra quais são.
O group by agrupa os valores iguais, como se fosse um só; mas todos existem. Ele mostra
quantos são.

Podemos também adicionar a função de agregação count() para contar quantos campos foram
agrupados. Veja a sintaxe abaixo:

Esse código irá mostrar o campo, e irá contar quantos campos foram agrupados.

Ex.2: Contar quantos cursos tem cada carga horária:

94
 Ou seja, existem 9 cursos com 40 de carga, 4 com 20 de carga...

Também podemos selecionar o agrupamento com campos com contagens específicas usando o
having com o count(). Veja a sintaxe abaixo:

Ex.3: Quais são as cargas de cursos que possuem pelo menos 5 cursos, em ordem crescente:

Ex:4: Contar quantos cursos que possuem a carga maior que a média da carga de todos os cursos:

Vale destacar que o having carga possui o select avg(carga) from cursos dentro de parênteses
porque para se calcular a média de algo é necessário utilizar o comando select, e como não pode
haver comandos dentro de comandos, é usado dentro de parêntese.

95
Exercícios
01 – Digamos que você trabalha gerenciando um banco de dados de pessoas no governo de sua
cidade. O seu chefe veio até você e disse que há algumas pesquisas que o governo quer fazer com
seus usuários e que ele precisa que você acesse o e-mail que ele lhe mandou com as instruções para
que você code e lhe retorne o resultado.

a. “Uma lista com as profissões das pessoas e seus respectivos quantitativos.”

b. “Quantos usuários homens e quantas mulheres nasceram após 01/01/2005?”

c. “Uma lista com os usuários que nasceram fora do Brasil, mostrando o país de origem e o
total de pessoas nascidas lá. Só nos interessam os países que tiveram mais de 3 usuários com
essa nacionalidade.”

d. “Uma lista agrupada pela altura dos usuários, mostrando quantas pessoas pesam mais de
100kg e que estão acima da média de altura de todos os cadastrados.”

96
Correção dos exercícios
1.º. Questão:
a.

b.

c.

d.

97
98
Capítulo IV - Modelo Relacional
O modelo relacional foi o responsável por melhorar a ligação de registros num banco de dados,
possibilitando a criação de várias relações e com significado.

No modelo relacional, nós temos as seguintes coisas: Entidades, representadas por retângulos;
Atributos, representados por elipses; e Relacionamentos, representados por losangos. Veja um
exemplo no nosso banco de dados com usuários e cursos:

usuários assiste curso

O modelo nesse formato é chamado de Diagrama ER, ou apenas DER.

99
Cardinalidade
A cardinalidade de um modelo relacional nada mais é do que limitar o número de relações que
uma entidade pode ter com outra. Veja um exemplo abaixo:

• Muitos para muitos(n-n):

n n
estudante assiste curso

Analise a imagem acima, perceba que vários estudantes podem fazer o mesmo curso e os
cursos podem ser assistidos por vários estudantes, ou seja, n para n.

• Um para um(1-1):
1 1
marido casa com esposa

Analise a imagem acima, perceba que um marido só pode se casar com uma esposa, e uma
esposa só pode se casar com um marido; ou seja, 1 para 1.

• Um para muitos(1-n):
1 n
funcionário cuida dependente

Analisando a imagem acima, perceba que um funcionário pode cuidar de vários

dependentes, mas um dependente só pode ser cuidado por um funcionário; ou seja, 1 para n.

100
 Chaves Estrangeiras
As chaves estrangeiras, nada mais são do que chaves primárias de um registro ‘a’ que são
copiadas e enviadas para outro registro ‘b’, assim se transformando em uma chave estrangeira. Vale
destacar que a chave estrangeira pode mudar de nome, mas o seu tipo primitivo deve sempre ser
igual.

Visualize melhor:

E
P
P b
P
a

Agora veja um exemplo prático:

1 1
marido casa com esposa

P nome P
nome
cpf-marido cpf-esposa
E

cpf-marido

Perceba que a entidade marido possui sua chave única—o cpf-marido—, e ela foi passada para
entidade esposa como chave estrangeira.

Vale destacar que isso só acontece nos casos de 1-1 e 1-n. Agora veja como isso ocorre no caso
n-n:
1 n n 1
cliente compra
cliente produto

P P
P
cpf data E
nome id-compra nome
cod-prod cod-prod
E preco
forma-pagto
101
cpf-cliente
Agora note que:

1. O relacionamento virou um relacionamento dentro de uma entidade;

2. Foram criados mini-relacionamentos para se conectar com o relacionamento compra com as
entidades cliente e produto;
3. Nova cardinalidade 1-n criada entre cliente e compra, e produto e compra. Um cliente pode
fazer n compras; um produto pode ser usado em n compras;
4. O relacionamento compra recebe a chave primária id-compra;
5. A chave primária cpf da entidade cliente é enviada para a entidade/relacionamento compra
como chave estrangeira, onde ganha o nome cpf-cliente, enquanto a chave primária cod-
prod da entidade produto vira chave estrangeira na entidade/relacionamento compra.

102
Engines
Se você abrir o seu dump com o aplicativo Notepad++, por exemplo, você pode achar um texto
engine logo após um create table. Geralmente, essa engine é o InnoDB, que é uma máquina de
criação de tabelas.
InnoDB, pertencente à Oracle, permite a criação de tabelas com suporte à chaves estrangeiras.

Também existem outras engines, como o MyISAM, que é antiga; e a XtraDB, mais atual.
Antigamente, se usava muito a engine MyISAM, porém ela não concordava com as regras
complacentes de uma transação—transação é tudo o que você pedir para um banco de dados, e que
ele vai executar e lhe dar uma resposta—, a ACID:
• Atomicidade: Ou toda a tarefa é feita e dá certo, ou nada será considerado; ou é faz tudo, ou
não faz nada;
• Consistência: Se o banco de dados, antes da transação, estiver ok; no fim da transação ele
deve permanecer ok;
• Isolamento: Se duas ou mais transações estiverem acontecendo em paralelo, elas devem
acontecer como se estivessem sendo executadas de forma isolada;
• Durabilidade: Uma transação deve ser durável, ou seja, o dado tem que ser durar o tempo
que for necessário.

103
Adicionando a Foreign Key em um caso 1-n
Suponhamos que os cursos só podem ser assistidos por um usuário por vez, mas um usuário pode
assistir vários cursos. Tendo as tabelas cursos e usuarios, vamos adicionar o a coluna idcurso da
tabela ‘curso’ como chave estrangeira na tabela ‘usuarios’. Para isso, siga os passos abaixo:

1.º. Crie uma nova coluna para a chave estrangeira(Lembre-se que o tipo primitivo da coluna
precisa, obrigatoriamente, ser a mesma da chave estrangeira):

2.º. Informe que a coluna ‘cursopreferido’ será a chave estrangeira, e também informe a
referencia de onde ela vai pegar a chave(no nosso caso, a referencia é a coluna ‘idcurso’ da
tabela ‘cursos’):

Visualize a última coluna:

104
Adicionando um valor na chave estrangeira
É possível adicionar um valor na chave primária. E para isso, vamos informar que o
‘cursopreferido’ do usuário Daniel Morais é ‘1’, ou seja, HTML5:

Porém há uma maneira mais fácil de adicionar chaves primárias nos usuários. Para isso, você
clica sobre o campo ‘null’. Veja:
• Clique sobre o campo que deseja escrever manualmente:

• Escreva o valor que deseja e aperte ENTER:

• Clique no botão ‘Apply’ para confirmar:

105
 • Aparecerá essa janela confirmando, e ela também lhe mostra o código que será utilizado
para realizar a alteração:

• E então, a alteração será feita:

Agora, faça o mesmo e adicione alguns cursos preferidos entre os usuários. Agora veja um
exemplo de como ficou:

106
107
Integridade Referencial
Uma coisa interessante das chaves estrangeiras é que elas criam uma integridade referencial que
lhe impede de deletar um curso, por engano, que seja uma chave estrangeira. Veja:

O Workbench vai lhe mostrar esse erro: ‘Error Code: 1451. Cannot delete or update a parent row:
a foreign key constraint fails (`cadastro`.`usuarios`, CONSTRAINT `usuarios_ibfk_1` FOREIGN
KEY (`cursopreferido`) REFERENCES `cursos` (`idcurso`))’.
Resumindo, o Workbench lhe informa que não é possível deletar o curso com ‘idcurso = 1’, pois
ele está sendo usado como chave estrangeira em outra tabela.

108
JOIN
O join, nada mais é do que fazer uma junção de uma tabela com outra em um result set. Vamos
fazer. Veja um exemplo onde vamos fazer um result set com o nome do usuário, seu cursopreferido,
o nome de seu curso preferido, e o ano de seu curso preferido:

Parece difícil, né? Vamos destrinchar esse código: selecione(select) nome da tabela
usuarios([Link]), cursopreferido da tabela usuarios([Link]), nome da
tabela cursos([Link]), ano da tabela cursos([Link]) de(from) usuarios, e junte(join) cursos
onde(on) o idcurso da tabela cursos([Link]) for igual(=) cursopreferido da tabela
usuarios([Link]).
Melhorou um pouco? Agora veja o result set:

Note que, no result set, só foi mostrado os usuários que possuem um cursopreferido. Isso ocorre
porque quando utilizamos o join, na verdade, acontece um inner join, que só mostra os que possuem
chave estrangeira.
Para que o result set mostre até os usuários que não possuem chave estrangeira, precisamos utilizar
um left outer ou right outer antes do join, dando prioridade a tabela da esquerda(left) ou
direita(right). Porém especificar o outer é opcional, o select vai entender com apenas left ou right.
Veja um exemplo com o left e right:

• left join:

109
 Note que no código, a tabela que está à esquerda(left) é a tabela de usuarios, então ela foi
priorizada.

• right join:

Note que no código, a tabela cursos está a direita(right) do join; então a tabela cursos foi
priorizada, mostrando até mesmo os cursos que ninguém tem como cursopreferido.

110
Aplicando ‘apelidos’ com o JOIN
É possível aplicar ‘apelidos’ quando vamos utilizar o comando select com o join, isso serve para
deixar o código mais limpo e organizado. Para isso, faça: nome_da_tabela as nome_do_apelido.
Vale destacar que o as utilizado anteriormente significa ‘como’. Agora veja o mesmo select de
antes, mas agora com apelidos:

Perceba que aplicamos os apelidos quando vamos informar as tabelas, e no resto dos campos nós
substituímos o nome da tabela pelo seu apelido.

111
INNER JOIN com Várias Tabelas
Agora, digamos que n usuários podem assistir n cursos, e n cursos podem ser assistidos por n
usuários; n-n.
Lembra de quando foi explicado como funciona o caso n-n, onde o relacionamento se tornou
uma entidade(pág. 71)? Vamos criar a entidade para esse relacionamento:

Vamos entender o código:

1. Criamos uma tabela chamada usuario_assiste_curso;
2. Criamos um id para o relacionamento chamado id;
3. Criamos um atributo data;
4. Criamos o idcurso como int que será a chave estrangeira vinda da tabela cursos;
5. Criamos o idusuario como int que será outra chave estrangeira vinda da tabela usuarios;
6. Definimos a chave primária como id;
7. Definimos a chave estrangeira idusuario tendo referência a chave primária id da tabela
usuarios;
8. Definimos outra chave estrangeira idcurso tendo referência a chave primária idcurso da
tabela cursos.

Veja o result set:

Vale destacar que a chave primária id ganha automaticamente o parâmetro not null quando
estabelecemos que ela é uma chave primária com auto_increment.

Mas como esse relacionamento funciona?

Entenda que, como é um relacionamento de muitos para muitos—n-n—, os dados do usuário

serão enviado para a entidade/relacionamento assiste enquanto os dados dos cursos também serão
enviados para a entidade/relacionamento assiste.

112
Inserindo os registros no caso n-n
Para inserir dados nessa entidade/relacionamento, vamos utilizar o insert into normalmente.
Veja:

Lembre-se que a ordem dos dados são: id, data, idcurso, idusuario; ou seja, o usuário ‘2’ tem está
fazendo o curso ‘1’.

Veja o result set:

Agora utilize o result set para adicionar mais dados:

113
JOIN no Caso n-n
Agora, como vamos poder utilizar o select para mostrar o id do relacionamento, o nome do
usuário, o nome do curso, e o ano do curso?
Lembra que para juntar uma tabela em outra foi utilizado apenas um JOIN? No nosso caso,
temos que juntar duas tabelas(usuarios e cursos) para dar o select na nossa tabela de
relacionamento. Veja o código abaixo:

Entenda o código:
1. Selecionamos o que queremos ver: id da tabela usuario_assiste_curso; nome da tabela
usuario; nome da tabela cursos; e ano da tabela cursos. Isso tudo da tabela
usuario_assiste_curso;
2. Juntamos a tabela usuarios na tabela usuario_assiste_curso;
3. Informamos que a tabela usuarios vai se juntar a tabela usuario_assiste_curso onde o id do
usuario da tabela usuario for igual ao idusuario da tabela usuario_assiste_curso;
4. Juntamos a tabela cursos na tabela usurio_assiste_curso;
5. Informamos que a tabela usuarios vai se juntar a tabela usuario_assiste_curso onde o idcurso
da tabela cursos for igual a idcurso da tabela usuario_assiste_curso.

Também é possível adicionar apelidos para ficar mais fácil a visualização do código, veja:

Perceba que o uso do as é opcional, ou seja, não é obrigatório; você pode apenas colocar o
apelido sem problemas.

Com tudo isso em mente, visualize o result set:

E você ainda pode melhorar esse result set informando a data da tabela usuario_assiste_curso, as
chaves estrangeiras como idcurso da tabela cursos, e idusuario da tabela usuario; veja:

114
115