2025

Aprendendo SQL

Pablo Oliveira
IFSC - Canoinhas
4/4/2025
Sumário
1. Introdução ao MySQL e SQL ................................................................... 2
2. Conectando e Interagindo com o MySQL ................................................... 3
3. DDL (Data Definition Language) - Definindo a Estrutura do Banco de Dados......... 4
3.1. CREATE DATABASE - Criando um Banco de Dados ................................... 4
3.2. CREATE TABLE - Criando Tabelas....................................................... 5
3.3. ALTER TABLE - Modificando a Estrutura de Tabelas................................. 7
3.4. DROP DATABASE - Excluindo um Banco de Dados.................................... 8
3.5. DROP TABLE - Excluindo Tabelas ....................................................... 9
3.6. RENAME TABLE - Renomeando Tabelas ............................................... 10
3.7. TRUNCATE TABLE - Limpando Tabelas ............................................... 11
4. CRUD (Create, Read, Update, Delete) - Manipulando Dados .......................... 12
4.1. Create (Inserir Dados) - INSERT INTO ................................................. 12
4.2. Read (Ler/Consultar Dados) - SELECT ................................................ 15
4.3. Update (Atualizar Dados) - UPDATE................................................... 18
4.4. Delete (Excluir Dados) - DELETE FROM ............................................... 20
5. Views ............................................................................................ 21
6. Joins ............................................................................................. 24
7. Funções (Functions) .......................................................................... 27
8. Procedures (Stored Procedures) ............................................................ 29
9. Triggers ......................................................................................... 32
10. Comandos SQL que Retornam o Número de Linhas Afetadas ......................... 34
11. Outros Conceitos Importantes ............................................................. 37
Índices ........................................................................................... 37
Constraints (Restrições): ..................................................................... 38
Transações: ..................................................................................... 39
Normalização Básica: ......................................................................... 40
Tabela de Referência Rápida dos Principais Comandos SQL .............................. 41
Referências ........................................................................................ 43

Sequência de Aprendizado Completa e Detalhada sobre SQL com MySQL

Com base em uma série conteúdo de referência, apresento uma sequência de
aprendizado progressiva sobre SQL, focada no MySQL, com explicações detalhadas,
exemplos práticos e sugestões de aplicabilidade.

1
1. Introdução ao MySQL e SQL

Explicações Detalhadas: O MySQL é um Sistema de Gerenciamento de Banco de

Dados Relacional (SGBDR). Em um banco de dados relacional, os dados são
armazenados em tabelas separadas, o que proporciona velocidade e flexibilidade em
comparação com armazenar todos os dados em um único local. A parte SQL de "MySQL"
refere-se à Structured Query Language (Linguagem Estrutural de Consultas).

O SQL é a linguagem padrão mais comum utilizada para acessar e manipular bancos
de dados, sendo definida pelo padrão ANSI/ISO SQL. Este padrão tem evoluído desde
1986, com diversas versões, como SQL-92 (1992), SQL-99 (1999) e SQL:2003 (em
desenvolvimento em meados de 2003). Ao longo deste aprendizado, referir-nos-emos
geralmente a "o padrão SQL" como a versão atual. O MySQL oferece diversos recursos
e funcionalidades que o tornam uma ferramenta poderosa para gerenciar dados. É
gratuito para uso comercial e privado, seguindo a licença pública GPL.

Exemplos Comentados: Não há exemplos de código SQL nesta seção introdutória, mas
é fundamental entender que todos os comandos SQL interagem com os dados
armazenados nas tabelas do seu banco de dados.

Sugestões de Aplicabilidade Prática: Quase todas as aplicações modernas, desde sites

web e sistemas de comércio eletrônico até sistemas internos de gerenciamento de
empresas, utilizam bancos de dados SQL para armazenar e gerenciar informações.
Compreender SQL é essencial para qualquer pessoa que trabalhe com desenvolvimento
de software, análise de dados ou administração de sistemas.

Propostas de Exercícios Guiados:

1. Pesquise sobre a história das diferentes versões do padrão SQL (SQL-92,

SQL-99, SQL:2003).

2. Explore o site oficial do MySQL (www.mysql.com) e familiarize-se com

a documentação.

Erros Comuns e Boas Práticas: Um erro comum é não compreender a natureza

relacional do banco de dados, o que pode levar a um design de tabelas ineficiente. A
boa prática inicial é conceitualizar os dados em entidades distintas (tabelas) e
definir os relacionamentos entre elas.

2
2. Conectando e Interagindo com o MySQL

Explicações Detalhadas: Para interagir com um servidor MySQL, você geralmente

utiliza um cliente MySQL, como o programa de linha de comando mysql. Para se
conectar, você precisará das credenciais de acesso (nome de usuário, senha e o
endereço do servidor).

Uma vez conectado, o prompt mysql> indica que o sistema está pronto para receber
comandos. Você pode obter ajuda sobre os comandos disponíveis usando o comando
help. Para encerrar a conexão, utilize o comando QUIT ou exit.

• Exemplos Comentados:

• mysql -u seu_usuario -p -h endereco_do_servidor

o mysql: Invoca o cliente de linha de comando MySQL.

o -u seu_usuario: Especifica o nome de usuário para a conexão. Substitua

seu_usuario pelo seu nome de usuário.

o -p: Solicita a senha do usuário.

o -h endereco_do_servidor: Especifica o endereço do servidor MySQL.

Omita se o servidor estiver local.

• mysql> help

o Exibe a lista de comandos disponíveis no cliente mysql.

• mysql> quit

• Bye

o Encerra a sessão com o servidor MySQL.

Sugestões de Aplicabilidade Prática: A capacidade de conectar e desconectar de um

servidor MySQL é o primeiro passo essencial para qualquer interação com o banco de
dados. A ferramenta de linha de comando mysql é útil para administração,
desenvolvimento e execução rápida de consultas.

Propostas de Exercícios Guiados:

2. Tente conectar-se a um servidor MySQL (se você tiver acesso a um).

3. Use o comando help para listar os comandos e explore a descrição de alguns

deles (por exemplo, status, connect, clear).

3
4. Desconecte-se do servidor.

• Erros Comuns e Boas Práticas: Erros comuns incluem digitar credenciais

incorretas ou tentar conectar-se a um servidor inacessível. Uma boa prática
é armazenar suas credenciais de forma segura e verificar a conectividade de
rede se houver problemas.

3. DDL (Data Definition Language) - Definindo a

Estrutura do Banco de Dados
DDL é o conjunto de comandos SQL utilizado para definir e modificar a estrutura do
banco de dados, incluindo a criação, alteração e exclusão de bancos de dados e
tabelas.

3.1. CREATE DATABASE - Criando um Banco de Dados

Explicações Detalhadas: O comando CREATE DATABASE é usado para criar um novo

banco de dados no servidor MySQL. A sintaxe básica é CREATE DATABASE
nome_do_banco_de_dados;.

No Unix, nomes de bancos de dados são sensíveis a maiúsculas e minúsculas. Após a

criação, para usar o banco de dados, você precisa selecioná-lo explicitamente com o
comando USE nome_do_banco_de_dados;. A opção IF NOT EXISTS pode ser usada para
evitar erros se o banco de dados já existir.

Exemplos Comentados:

• CREATE DATABASE meu_banco_de_dados;

o Cria um banco de dados chamado meu_banco_de_dados.

• USE meu_banco_de_dados;

o Seleciona meu_banco_de_dados para uso.

• CREATE DATABASE IF NOT EXISTS outro_banco;

o Cria o banco de dados outro_banco somente se ele não existir.

• Sugestões de Aplicabilidade Prática: Antes de criar tabelas e armazenar

dados, você precisa de um banco de dados. A criação de bancos de dados é uma
tarefa fundamental na configuração inicial de um sistema.

Propostas de Exercícios Guiados:

4
1. Crie um banco de dados chamado escola.

2. Selecione o banco de dados escola para uso.

3. Tente criar novamente o banco de dados escola sem usar IF NOT EXISTS e
observe o erro.

4. Crie um banco de dados chamado biblioteca usando IF NOT EXISTS.

Erros Comuns e Boas Práticas: Um erro comum é tentar criar um banco de dados
com um nome inválido (por exemplo, contendo espaços sem aspas). Uma boa prática
é escolher nomes descritivos e seguir as convenções de nomenclatura do seu
ambiente. Lembre-se da sensibilidade a maiúsculas e minúsculas em alguns sistemas.

3.2. CREATE TABLE - Criando Tabelas

Explicações Detalhadas: O comando CREATE TABLE é usado para criar novas tabelas
dentro do banco de dados selecionado. Você precisa definir o nome da tabela e as
colunas que ela conterá, especificando o nome de cada coluna e seu tipo de dados.
Você também pode definir restrições (constraints) como chaves primárias (PRIMARY
KEY) e chaves únicas (UNIQUE).

Tabelas InnoDB suportam restrições de chaves estrangeiras (FOREIGN KEY) com

opções como ON DELETE CASCADE e ON UPDATE. Para outros tipos de tabela, o MySQL
pode apenas analisar a sintaxe de FOREIGN KEY sem aplicá-la imediatamente. Você
pode usar IF NOT EXISTS para criar a tabela somente se ela não existir.

O comando SHOW CREATE TABLE nome_tabela exibe a instrução CREATE TABLE usada
para criar uma tabela. Você também pode criar uma tabela baseada no resultado de
uma consulta SELECT usando CREATE TABLE nova_tabela SELECT colunas FROM
tabela_existente;. Índices não são criados automaticamente nesse processo.

Exemplos Comentados:

CREATE TABLE IF NOT EXISTS clientes (

id INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
nome VARCHAR(255) NOT NULL,
email VARCHAR(255) UNIQUE,
data_cadastro TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

5
 o CREATE TABLE IF NOT EXISTS clientes: Cria uma tabela chamada clientes
se ela não existir.

o id INT UNSIGNED AUTO_INCREMENT PRIMARY KEY: Cria uma coluna id do

tipo inteiro não assinado, que se incrementa automaticamente a cada
nova linha e é a chave primária da tabela.

o nome VARCHAR(255) NOT NULL: Cria uma coluna nome para armazenar
strings de até 255 caracteres, e o valor não pode ser nulo.

o email VARCHAR(255) UNIQUE: Cria uma coluna email para strings de até
255 caracteres, e todos os valores devem ser únicos.

o data_cadastro TIMESTAMP DEFAULT CURRENT_TIMESTAMP: Cria uma

coluna data_cadastro para armazenar a data e hora do cadastro, com o
valor padrão sendo a data e hora atual.

• SHOW CREATE TABLE clientes;

o Exibe a instrução CREATE TABLE para a tabela clientes.

• CREATE TABLE clientes_ativos SELECT id, nome, email FROM clientes WHERE ...;

o Cria uma nova tabela clientes_ativos com base nos resultados de uma
consulta SELECT na tabela clientes.

Sugestões de Aplicabilidade Prática: A criação de tabelas é o núcleo do design do

banco de dados. A escolha correta dos tipos de dados e a definição de chaves e
restrições garantem a integridade e a eficiência do armazenamento dos dados.

Propostas de Exercícios Guiados:

1. Crie uma tabela chamada produtos com colunas para id (inteiro, chave primária,
auto incremento), nome (varchar(100), não nulo), preco (decimal(10, 2)), e
estoque (inteiro).

2. Use SHOW CREATE TABLE produtos para verificar a estrutura da tabela.

3. Crie uma segunda tabela chamada pedidos com colunas para id (inteiro, chave
primária, auto incremento), cliente_id (inteiro, chave estrangeira referenciando o
id da tabela clientes), e data_pedido (datetime). (Observe que a funcionalidade
completa de chave estrangeira pode depender do tipo da tabela).

6
4. Tente criar uma tabela com uma coluna do tipo TEXT para armazenar grandes
quantidades de texto.

Erros Comuns e Boas Práticas: Erros comuns incluem especificar tipos de dados
inadequados para os dados que serão armazenados, esquecer de definir chaves
primárias, e não considerar as relações entre as tabelas ao definir chaves
estrangeiras.

Boas práticas incluem planejar cuidadosamente a estrutura das tabelas, usar nomes
de colunas descritivos, e escolher os tipos de dados mais eficientes para cada
coluna.

3.3. ALTER TABLE - Modificando a Estrutura de Tabelas

Explicações Detalhadas: O comando ALTER TABLE é usado para modificar a estrutura

de uma tabela existente. Ele permite adicionar novas colunas (ADD), modificar
colunas existentes (MODIFY COLUMN ou CHANGE COLUMN), remover colunas (DROP
COLUMN), adicionar ou remover restrições (ADD CONSTRAINT, DROP CONSTRAINT), e
renomear colunas (CHANGE COLUMN).

A sintaxe detalhada para cada operação pode variar. Para modificar especificações de
colunas, consulte a documentação específica. É possível realizar múltiplas alterações
em uma única instrução ALTER TABLE.

• Exemplos Comentados:

• ALTER TABLE clientes ADD COLUMN telefone VARCHAR(20);

o Adiciona uma nova coluna chamada telefone do tipo varchar(20) à

tabela clientes.

• ALTER TABLE clientes MODIFY COLUMN nome VARCHAR(100) NOT NULL;

o Modifica a coluna nome na tabela clientes para ter um tamanho máximo

de 100 caracteres e garante que não pode ser nula.

• ALTER TABLE produtos DROP COLUMN estoque;

o Remove a coluna estoque da tabela produtos.

• ALTER TABLE pedidos ADD CONSTRAINT fk_cliente FOREIGN KEY (cliente_id) REFERENCES clientes(id);

7
 o Adiciona uma restrição de chave estrangeira chamada fk_cliente à
tabela pedidos, referenciando a coluna id da tabela clientes (suportado
em InnoDB).

• ALTER TABLE clientes CHANGE COLUMN nome nome_completo VARCHAR(150) NOT NULL;

o Renomeia a coluna nome para nome_completo e altera seu tipo para

varchar(150), mantendo a restrição NOT NULL.

Sugestões de Aplicabilidade Prática: As necessidades de um sistema podem mudar, e

ALTER TABLE permite adaptar o esquema do banco de dados sem perder os dados
existentes.

Propostas de Exercícios Guiados:

1. Adicione uma coluna endereco do tipo TEXT à tabela clientes.

2. Modifique o tipo da coluna preco na tabela produtos para DECIMAL(12, 2).

3. Remova a coluna telefone da tabela clientes.

4. Tente adicionar uma restrição UNIQUE à coluna nome da tabela produtos.

5. Renomeie a coluna data_cadastro na tabela clientes para cadastro_em.

Erros Comuns e Boas Práticas: Erros comuns incluem tentar alterar o tipo de dados
de uma coluna para um tipo incompatível com os dados existentes, tentar remover
uma coluna que é referenciada por uma chave estrangeira (sem remover a chave
estrangeira primeiro), e erros de sintaxe no comando ALTER TABLE.

Uma boa prática é fazer um backup do banco de dados antes de realizar alterações
estruturais, planejar as alterações cuidadosamente, e testar as alterações em um
ambiente de desenvolvimento antes de aplicá-las em produção.

3.4. DROP DATABASE - Excluindo um Banco de Dados

Explicações Detalhadas: O comando DROP DATABASE é usado para remover

completamente um banco de dados existente e todas as suas tabelas e objetos. A
sintaxe básica é DROP DATABASE nome_do_banco_de_dados;. Use este comando com
extrema cautela, pois a exclusão é irreversível e todos os dados serão perdidos. A
opção IF EXISTS pode ser usada para evitar erros se o banco de dados não existir.

Exemplos Comentados:

8
 • DROP DATABASE meu_banco_de_dados;

o Exclui o banco de dados meu_banco_de_dados e todo o seu conteúdo.

• DROP DATABASE IF EXISTS banco_de_teste;

o Exclui o banco de dados banco_de_teste somente se ele existir.

Sugestões de Aplicabilidade Prática: DROP DATABASE é usado para remover bancos

de dados que não são mais necessários, como ambientes de teste ou bancos de dados
obsoletos.

Propostas de Exercícios Guiados:

1. Crie um banco de dados de teste chamado teste_drop.

2. Crie algumas tabelas dentro de teste_drop.

3. Use DROP DATABASE teste_drop para excluir o banco de dados.

4. Tente excluir novamente teste_drop sem usar IF EXISTS e observe o erro.

5. Use DROP DATABASE IF EXISTS outro_teste_drop.

Erros Comuns e Boas Práticas: O erro mais grave é excluir um banco de dados em
produção por engano, resultando em perda de dados crítica. A boa prática
fundamental é ter certeza absoluta de que você deseja excluir o banco de dados
correto e ter backups recentes em caso de erro.

3.5. DROP TABLE - Excluindo Tabelas

Explicações Detalhadas: O comando DROP TABLE é usado para remover uma ou mais
tabelas existentes do banco de dados. A sintaxe básica é DROP TABLE
nome_da_tabela;.

Assim como DROP DATABASE, esta operação é irreversível e todos os dados da tabela
serão perdidos. Você pode excluir múltiplas tabelas com uma única instrução DROP
TABLE, separando os nomes por vírgula. A opção IF EXISTS pode ser usada para evitar
erros se a tabela não existir.

Exemplos Comentados:

• DROP TABLE clientes;

o Exclui a tabela clientes e todos os seus dados.

9
 • DROP TABLE produtos, pedidos;

o Exclui as tabelas produtos e pedidos.

• DROP TABLE IF EXISTS logs;

o Exclui a tabela logs somente se ela existir.

Sugestões de Aplicabilidade Prática: DROP TABLE é usado para remover tabelas que
não são mais necessárias ou que foram criadas para fins temporários.

Propostas de Exercícios Guiados:

2. Crie uma tabela de teste chamada temp_table.

3. Insira alguns dados em temp_table.

4. Use DROP TABLE temp_table para excluir a tabela.

5. Tente excluir novamente temp_table sem usar IF EXISTS e observe o erro.

6. Crie duas tabelas de teste (table_a e table_b) e exclua ambas com um único
comando DROP TABLE.

Erros Comuns e Boas Práticas: Um erro comum é excluir uma tabela que ainda é
necessária ou que possui relações com outras tabelas (chaves estrangeiras). A boa
prática é compreender as dependências entre as tabelas antes de excluí-las e ter
backups em caso de erro.

3.6. RENAME TABLE - Renomeando Tabelas

Explicações Detalhadas: O comando RENAME TABLE é usado para alterar o nome de

uma ou mais tabelas existentes. A sintaxe básica é RENAME TABLE nome_antigo TO
nome_novo;.

Você pode renomear múltiplas tabelas em uma única instrução, separando cada par de
nomes antigo/novo por vírgula.

Exemplos Comentados:

• RENAME TABLE clientes TO usuarios;

o Renomeia a tabela clientes para usuarios.

• RENAME TABLE produtos TO itens, pedidos TO compras;

10
 o Renomeia a tabela produtos para itens e a tabela pedidos para compras.

Sugestões de Aplicabilidade Prática: Renomear tabelas pode ser útil para melhorar a
clareza e a consistência do esquema do banco de dados.

Propostas de Exercícios Guiados:

1. Crie uma tabela chamada temp.

2. Use RENAME TABLE temp TO temporary.

3. Renomeie novamente a tabela para temp_final.

4. Crie duas tabelas (old_table_1 e old_table_2) e renomeie-as para new_table_1 e

new_table_2 com um único comando RENAME TABLE.

Erros Comuns e Boas Práticas: Um erro comum é tentar renomear uma tabela para
um nome que já existe. A boa prática é verificar se o novo nome está disponível
antes de realizar a renomeação.

3.7. TRUNCATE TABLE - Limpando Tabelas

Explicações Detalhadas: O comando TRUNCATE TABLE é usado para remover todas as

linhas de uma tabela de forma rápida e eficiente, mas mantém a estrutura da tabela
(colunas, índices, restrições).

Diferentemente de DELETE FROM tabela, TRUNCATE TABLE não registra as exclusões

individualmente (não gera logs de exclusão detalhados) e redefine o contador
AUTO_INCREMENT para o seu valor inicial.

Portanto, TRUNCATE TABLE é mais rápido para limpar grandes tabelas. No MySQL 4.0
e posterior, TRUNCATE é a forma recomendada para esvaziar tabelas grandes em vez
de DELETE FROM.

• Exemplos Comentados:

• TRUNCATE TABLE logs;

o Remove todas as linhas da tabela logs, mas mantém a estrutura da

tabela. O contador AUTO_INCREMENT (se houver) será resetado.

Sugestões de Aplicabilidade Prática: TRUNCATE TABLE é útil para limpar tabelas de

staging (áreas temporárias para processamento de dados), tabelas de log que precisam
ser reinicializadas, ou tabelas de teste antes de executar novos testes.

11
Propostas de Exercícios Guiados:

1. Crie uma tabela com uma coluna AUTO_INCREMENT e insira alguns dados.

2. Use TRUNCATE TABLE para limpar a tabela.

3. Insira novos dados e observe que o contador AUTO_INCREMENT reiniciou.

4. Compare o tempo de execução de TRUNCATE TABLE com DELETE FROM tabela em

uma tabela com muitos registros (se possível).

Erros Comuns e Boas Práticas: Um erro comum é usar TRUNCATE TABLE em uma
tabela que possui relações de chave estrangeira com outras tabelas, pois pode haver
restrições que impedem a operação.

A boa prática é ter cuidado ao usar TRUNCATE TABLE, pois a operação não pode ser
desfeita por meio de ROLLBACK em muitos SGBDs (verifique a documentação do MySQL
sobre comportamento transacional de DDL).

4. CRUD (Create, Read, Update, Delete) -

Manipulando Dados

CRUD representa as quatro operações básicas para manipular dados em um banco de

dados: Create (Inserir), Read (Ler/Consultar), Update (Atualizar) e Delete (Excluir).

4.1. Create (Inserir Dados) - INSERT INTO

Explicações Detalhadas: O comando INSERT INTO é usado para adicionar novas linhas
(registros) a uma tabela. Existem várias formas de usar INSERT INTO:

Inserindo valores para todas as colunas: Se você fornecer valores para todas as
colunas da tabela na ordem em que foram definidas, pode omitir a lista de colunas. A
sintaxe é INSERT INTO nome_tabela VALUES (valor1, valor2, ...);.

Inserindo valores para colunas específicas: Você pode especificar as colunas para
as quais deseja fornecer valores. As colunas não especificadas receberão seus
valores padrão (se definidos) ou NULL. A sintaxe é INSERT INTO nome_tabela
(coluna1, coluna2, ...) VALUES (valor1, valor2, ...);.

Inserindo múltiplos registros de uma vez: Para reduzir a sobrecarga de

comunicação, você pode inserir múltiplos registros em uma única instrução INSERT

12
usando múltiplas listas de valores separadas por vírgula: INSERT INTO nome_tabela
(coluna1, coluna2) VALUES (valor1_1, valor1_2), (valor2_1, valor2_2), ...;.

Inserindo dados a partir de uma consulta SELECT: Você pode inserir dados em
uma tabela selecionando-os de outra tabela ou de uma consulta. A sintaxe é INSERT
INTO tabela_destino (coluna1, coluna2, ...) SELECT coluna_origem1,
coluna_origem2, ... FROM tabela_origem WHERE ...;. Se a lista de colunas for
omitida, os valores do SELECT devem corresponder à ordem das colunas na tabela
de destino.

o A sintaxe INSERT INTO ... SET col_name = valor, ... também é suportada.
o As cláusulas DELAYED e LOW_PRIORITY podem ser usadas em instruções
INSERT para influenciar a prioridade da inserção.
o REPLACE pode ser usado no lugar de DELETE + INSERT para evitar
duplicidades em chaves únicas.
o INSERT IGNORE permite ignorar erros de chave duplicada.
o Para descobrir a ordem das colunas, use DESCRIBE nome_tabela.
o A função LAST_INSERT_ID() retorna o último valor inserido em uma
coluna AUTO_INCREMENT.

Exemplos Comentados:

-- Inserindo um novo cliente fornecendo valores para todas as colunas (assumindo

a ordem: id, nome, email, data_cadastro)

INSERT INTO clientes VALUES (NULL, 'João da Silva', '[email protected]', DEFAULT);

o INSERT INTO clientes: Especifica a tabela onde os dados serão inseridos.

o VALUES (...): Lista os valores para cada coluna.

o NULL: Deixa que o valor para a coluna id (AUTO_INCREMENT) seja gerado

automaticamente.

o 'João da Silva': Valor para a coluna nome.

o '[email protected]': Valor para a coluna email.

o DEFAULT: Usa o valor padrão definido para a coluna data_cadastro

(CURRENT_TIMESTAMP).

-- Inserindo um novo produto especificando as colunas

INSERT INTO produtos (nome, preco) VALUES ('Notebook', 1200.50);

13
 o INSERT INTO produtos (nome, preco): Especifica a tabela e as colunas
que receberão valores.

o VALUES ('Notebook', 1200.50): Fornece os valores correspondentes para

as colunas nome e preco. A coluna id será auto incrementada e estoque
assumirá seu valor padrão (se definido, senão NULL).

-- Inserindo múltiplos pedidos de uma vez

INSERT INTO pedidos (cliente_id, data_pedido) VALUES (1, NOW()), (2, NOW()), (1, DATE_SUB(NOW(), INTERVAL 1 DAY));

o Insere três novos registros na tabela pedidos com diferentes valores para
cliente_id e data_pedido (usando funções de data e hora).

-- Inserindo clientes ativos de uma tabela de potenciais clientes

INSERT INTO clientes (nome, email) SELECT nome_completo, email_contato FROM potenciais_clientes WHERE ativo = 1;

o INSERT INTO clientes (nome, email): Especifica as colunas de destino.

o SELECT nome_completo, email_contato FROM potenciais_clientes

WHERE ativo = 1: Seleciona os dados da tabela potenciais_clientes para
serem inseridos na tabela clientes, filtrando apenas os clientes ativos.

Sugestões de Aplicabilidade Prática: INSERT INTO é fundamental para popular as

tabelas do seu banco de dados com os dados da sua aplicação.

Propostas de Exercícios Guiados:

1. Insira três novos clientes na tabela clientes (criada anteriormente) usando as

diferentes formas de INSERT INTO mostradas nos exemplos.

2. Insira alguns produtos na tabela produtos.

3. Crie uma tabela temporária temp_clientes com algumas colunas em comum com
clientes e insira alguns dados nela. Depois, use INSERT INTO ... SELECT para copiar
dados de temp_clientes para clientes.

Erros Comuns e Boas Práticas: Erros comuns incluem fornecer um número incorreto
de valores para as colunas, tentar inserir valores de tipos incompatíveis, e violar
restrições como NOT NULL ou UNIQUE.

Boas práticas incluem sempre especificar as colunas no INSERT INTO para maior
clareza e evitar problemas com alterações na estrutura da tabela, validar os dados

14
da aplicação antes de inserir no banco de dados, e usar inserções em lote (INSERT
com múltiplos VALUES) para melhor performance ao inserir muitos registros.

4.2. Read (Ler/Consultar Dados) - SELECT

Explicações Detalhadas: O comando SELECT é o coração da linguagem SQL e é usado

para recuperar informações (consultar dados) de uma ou mais tabelas.

A forma geral da instrução SELECT é: SELECT o_que_mostrar FROM de_qual_tabela

WHERE condições_para_satisfazer ORDER BY quais_colunas LIMIT quantos_registros;.

o SELECT o_que_mostrar: Especifica as colunas que você deseja

recuperar. Pode ser uma lista de nomes de colunas separados por
vírgula, ou * para selecionar todas as colunas. Você pode usar aliases
para renomear as colunas na saída usando a palavra-chave AS.

o FROM de_qual_tabela: Indica a tabela ou tabelas das quais você deseja

recuperar os dados. Você também pode usar aliases para tabelas. É
possível misturar tabelas de diferentes bancos de dados na mesma
consulta (como na versão 3.22).

o WHERE condições_para_satisfazer: É uma cláusula opcional que filtra

os registros com base em condições especificadas. Você pode usar
operadores de comparação (=, >, <, >=, <=, <>, !=), operadores lógicos
(AND, OR, NOT), o operador LIKE para correspondência de padrões (%
para qualquer sequência de caracteres, _ para um único caractere), o
operador IN para verificar se um valor está em uma lista, o operador
BETWEEN para verificar se um valor está dentro de um intervalo, e IS
NULL ou IS NOT NULL para verificar valores nulos. LIKE é permitido em
campos numéricos.

o ORDER BY quais_colunas: É uma cláusula opcional que especifica a

ordem em que os resultados devem ser exibidos. Você pode ordenar por
uma ou mais colunas, em ordem crescente (ASC, padrão) ou decrescente
(DESC).

o LIMIT quantos_registros: É uma cláusula opcional que limita o número

de registros retornados pela consulta. Você pode especificar apenas o
número de linhas ou um deslocamento e o número de linhas (por

15
 exemplo, LIMIT 10 ou LIMIT 5, 10). Variáveis SQL podem ser usadas em
LIMIT (como em LIMIT @a,@b).

o A cláusula DISTINCT pode ser usada para retornar apenas valores únicos.

o Você pode usar funções em cláusulas SELECT e WHERE.

o As cláusulas GROUP BY e HAVING são usadas para agrupar resultados e

filtrar grupos, respectivamente. Funções de agrupamento como
COUNT(), AVG(), SUM(), MIN(), MAX() são suportadas.

o Subqueries (consultas aninhadas) são suportadas e podem ser usadas

em diversas partes da instrução SELECT (cláusula WHERE, cláusula
FROM, como operandos escalares).

o JOIN é usado para combinar linhas de duas ou mais tabelas com base em
uma condição relacionada. Os diferentes tipos de JOIN serão detalhados
posteriormente.

o O comando EXPLAIN SELECT ... mostra como o MySQL pretende executar

a consulta, ajudando na otimização.

o O comando SHOW pode ser usado para obter informações sobre bancos
de dados, tabelas e índices. Por exemplo, SHOW COLUMNS FROM
nome_tabela ou DESCRIBE nome_tabela mostram a estrutura de uma
tabela. SHOW INDEX FROM nome_tabela exibe informações sobre os
índices. mysqlshow nome_db nome_tabela também pode ser usado para
exibir informações sobre tabelas e colunas.

Exemplos Comentados:

-- Selecionando todos os clientes

SELECT * FROM clientes;

SELECT *: Seleciona todas as colunas da tabela.
FROM clientes: Especifica a tabela a ser consultada.
-- Selecionando nome e email dos clientes com ID maior que 5
SELECT nome, email FROM clientes WHERE id > 5;
SELECT nome, email: Seleciona apenas as colunas nome e email.
FROM clientes: Especifica a tabela.
WHERE id > 5: Filtra os resultados para incluir apenas clientes com id maior que 5.

16
 -- Selecionando produtos com preço entre 100 e 500, ordenados por preço em
ordem decrescente

SELECT nome, preco FROM produtos WHERE preco BETWEEN 100 AND 500 ORDER BY preco DESC;

o WHERE preco BETWEEN 100 AND 500: Filtra produtos com preço dentro
do intervalo especificado.

o ORDER BY preco DESC: Ordena os resultados pela coluna preco em

ordem decrescente.

-- Selecionando os 3 clientes cadastrados mais recentemente

SELECT nome, data_cadastro FROM clientes ORDER BY data_cadastro DESC LIMIT 3;

o ORDER BY data_cadastro DESC: Ordena os clientes pela data de cadastro

mais recente primeiro.

o LIMIT 3: Limita o número de resultados a 3.

-- Contando o número total de clientes

SELECT COUNT(*) AS total_clientes FROM clientes;

o COUNT(*): Função de agregação que conta o número de linhas.

o AS total_clientes: Atribui um alias total_clientes à coluna resultante.

Sugestões de Aplicabilidade Prática: SELECT é usado em todas as aplicações que

precisam exibir dados do banco de dados, desde listagens simples até relatórios
complexos e dashboards.

Propostas de Exercícios Guiados:

1. Selecione todos os dados da tabela produtos.

2. Selecione apenas os nomes dos produtos com estoque maior que 10.

3. Selecione os 5 produtos mais caros.

4. Conte o número de produtos com preço inferior a 100.

5. Selecione os emails únicos da tabela clientes.

6. Use EXPLAIN SELECT * FROM clientes WHERE nome LIKE 'J%'; para ver o plano de
execução da consulta.

7. Use SHOW COLUMNS FROM clientes; para visualizar a estrutura da tabela.

17
Erros Comuns e Boas Práticas: Erros comuns incluem erros de sintaxe, esquecer a
cláusula WHERE em consultas que deveriam ser filtradas, usar aliases que conflitam
com nomes de colunas existentes, e não otimizar consultas para grandes volumes
de dados (usando EXPLAIN e índices).

Boas práticas incluem ser específico sobre as colunas que você precisa, usar a
cláusula WHERE para limitar os resultados sempre que possível, ordenar os
resultados apenas quando necessário, e criar índices nas colunas frequentemente
usadas em cláusulas WHERE e ORDER BY para melhorar a performance.

4.3. Update (Atualizar Dados) - UPDATE

Explicações Detalhadas: O comando UPDATE é usado para modificar dados existentes

em uma ou mais linhas de uma tabela. A sintaxe básica é UPDATE nome_tabela SET
coluna1 = novo_valor1, coluna2 = novo_valor2, ... WHERE condição;.

o UPDATE nome_tabela: Especifica a tabela que será atualizada.

o SET coluna1 = novo_valor1, ...: Define as colunas que serão modificadas

e seus novos valores. Você pode atualizar várias colunas em uma única
instrução, separando as atribuições por vírgula.

o WHERE condição: É uma cláusula crucial que especifica quais linhas

serão atualizadas. Se a cláusula WHERE for omitida, todas as linhas da
tabela serão atualizadas, o que geralmente não é o desejado. A
condição na cláusula WHERE segue as mesmas regras das condições na
cláusula WHERE do comando SELECT.

o As cláusulas ORDER BY e LIMIT podem ser usadas com UPDATE para

especificar a ordem em que as linhas são atualizadas e limitar o número
de linhas afetadas.

o A cláusula LOW_PRIORITY pode ser usada para dar menor prioridade à

operação de atualização.

Exemplos Comentados:

-- Atualizando o email de um cliente específico

UPDATE clientes SET email = '[email protected]' WHERE id = 1;

o Atualiza a tabela clientes.

18
 o SET email = '[email protected]': Define o novo valor para a coluna
email.

o WHERE id = 1: Garante que apenas o cliente com id igual a 1 seja

atualizado.

-- Aumentando o preço de todos os produtos em 10%

UPDATE produtos SET preco = preco * 1.10;

o Atualiza todos os registros da tabela produtos (observe a ausência da

cláusula WHERE).

o SET preco = preco * 1.10: Atualiza o valor da coluna preco multiplicando-

o por 1.10.

-- Atualizando o estoque de um produto específico, limitando a 1 linha (se houver

várias correspondências)

UPDATE produtos SET estoque = estoque + 5 WHERE nome = 'Notebook' LIMIT 1;

o WHERE nome = 'Notebook': Filtra os produtos com o nome 'Notebook'.

o LIMIT 1: Atualiza no máximo uma linha correspondente.

Sugestões de Aplicabilidade Prática: UPDATE é usado para manter os dados do seu

banco de dados atualizados em resposta a ações dos usuários ou eventos do sistema.

Propostas de Exercícios Guiados:

1. Atualize o nome de um cliente específico na tabela clientes.

2. Aumente o preço de todos os produtos da categoria 'Eletrônicos' em 5%.

3. Defina o estoque de um produto específico para 0.

4. Tente atualizar o email de um cliente para um valor que já existe em outra linha
(se a coluna email tiver a restrição UNIQUE). Observe o erro.

Erros Comuns e Boas Práticas: O erro mais perigoso é esquecer a cláusula WHERE, o
que pode levar a atualizações indesejadas em toda a tabela. Outros erros incluem
tentar definir valores de tipos incompatíveis ou violar restrições.

Boas práticas incluem sempre usar a cláusula WHERE para especificar precisamente
quais linhas devem ser atualizadas, fazer um SELECT com a mesma cláusula WHERE

19
antes do UPDATE para verificar as linhas que serão afetadas, e ter backups em caso
de erro.

4.4. Delete (Excluir Dados) - DELETE FROM

Explicações Detalhadas: O comando DELETE FROM é usado para remover linhas

(registros) de uma tabela. A sintaxe básica é DELETE FROM nome_tabela WHERE
condição;.

o DELETE FROM nome_tabela: Especifica a tabela da qual as linhas serão

excluídas.

o WHERE condição: É fundamental para especificar quais linhas serão

excluídas. Se a cláusula WHERE for omitida, todas as linhas da tabela
serão excluídas, deixando a tabela vazia mas mantendo sua estrutura.

o As cláusulas ORDER BY e LIMIT também podem ser usadas com DELETE

para especificar a ordem de exclusão e limitar o número de linhas
afetadas.

o A cláusula LOW_PRIORITY pode ser usada para dar menor prioridade à

operação de exclusão.

o Se você estiver excluindo registros de uma tabela que tem chaves

estrangeiras com a propriedade ON DELETE CASCADE, a exclusão pode
se propagar para tabelas relacionadas.

o Para esvaziar uma tabela rapidamente, TRUNCATE TABLE (discutido

anteriormente) é geralmente preferível a DELETE FROM sem cláusula
WHERE.

Exemplos Comentados:

-- Excluindo um cliente específico

DELETE FROM clientes WHERE id = 3;

o Exclui a linha da tabela clientes onde a coluna id é igual a 3.

-- Excluindo todos os produtos com estoque zerado

DELETE FROM produtos WHERE estoque = 0;

20
 o Exclui todas as linhas da tabela produtos onde a coluna estoque é igual
a 0.

-- Excluindo os 2 clientes cadastrados mais antigos

DELETE FROM clientes ORDER BY data_cadastro ASC LIMIT 2;

o Ordena os clientes por data de cadastro mais antiga primeiro e exclui os

2 primeiros resultados.

Sugestões de Aplicabilidade Prática: DELETE FROM é usado para remover dados

obsoletos ou incorretos do seu banco de dados.

Propostas de Exercícios Guiados:

1. Exclua um produto específico da tabela produtos.

2. Exclua todos os clientes que não possuem um email registrado (onde a coluna email
é NULL).

3. Exclua os pedidos mais antigos da tabela pedidos (limitando a um certo número).

4. Se você configurou chaves estrangeiras com ON DELETE CASCADE, tente excluir um

cliente que possui pedidos associados e observe se os pedidos também são
excluídos.

Erros Comuns e Boas Práticas: O erro mais crítico é esquecer a cláusula WHERE, o
que resultará na exclusão de todos os dados da tabela. Outros erros incluem tentar
excluir linhas que são referenciadas por outras tabelas (violando restrições de chave
estrangeira, a menos que ON DELETE CASCADE esteja configurado).

Boas práticas incluem sempre usar a cláusula WHERE para especificar precisamente
quais linhas devem ser excluídas, fazer um SELECT com a mesma cláusula WHERE
antes do DELETE para verificar as linhas que serão afetadas, e ter backups em caso
de erro. Para esvaziar grandes tabelas, prefira TRUNCATE TABLE se a estrutura precisar
ser mantida e o AUTO_INCREMENT resetado.

5. Views

Explicações Detalhadas: Uma view (ou visão) é uma tabela virtual baseada no
resultado de uma consulta SELECT. As views não armazenam dados fisicamente; em

21
vez disso, elas armazenam a definição da consulta. Quando você consulta uma view,
o MySQL executa a consulta subjacente e retorna o resultado.

As views podem simplificar consultas complexas, permitindo que os usuários acessem

os dados como se estivessem em uma única tabela, mesmo que os dados reais estejam
distribuídos em várias tabelas. Elas também podem ser usadas para restringir o acesso
a dados específicos, expondo apenas um subconjunto das colunas ou linhas de uma ou
mais tabelas. Views não são estritamente necessárias para restringir o acesso a
registros, pois o MySQL possui um sistema de privilégios sofisticado.

Unnamed views (tabelas derivadas, uma subquery na cláusula FROM de um SELECT) já

estavam implementadas na versão 4.1. A implementação completa de views (com
nome) estava em desenvolvimento para as versões 5.0 e 5.1 do MySQL Server. Muitos
SGBDs não permitem atualizar registros diretamente em uma view, exigindo
atualizações nas tabelas base.

O objetivo na implementação de views no MySQL era buscar compatibilidade com a

"Codd's Rule #6", onde todas as views teoricamente atualizáveis deveriam ser
atualizadas na prática, dentro das limitações do SQL.

Exemplos Comentados: (Os exemplos podem variar dependendo da versão exata do

MySQL, pois o suporte a views foi sendo aprimorado)

-- Criando uma view que exibe apenas o nome e o email de clientes ativos
(assumindo que há uma coluna 'ativo')

CREATE VIEW vw_clientes_ativos AS

SELECT nome, email FROM clientes WHERE ativo = 1;
-- Consultando a view

SELECT * FROM vw_clientes_ativos;

-- Criando uma view que combina dados de clientes e seus pedidos (requer JOINS,
explicado posteriormente)

CREATE VIEW vw_pedidos_clientes AS

SELECT c.nome AS nome_cliente, p.id AS id_pedido, p.data_pedido
FROM clientes c
INNER JOIN pedidos p ON c.id = p.cliente_id;
-- Consultando a view combinada

SELECT * FROM vw_pedidos_clientes WHERE nome_cliente = 'João da Silva';

22
 -- (Exemplo de atualização, pode ter limitações)

-- UPDATE vw_clientes_ativos SET email = '[email protected]' WHERE nome =

'João da Silva';

o CREATE VIEW vw_clientes_ativos AS SELECT ...: Cria uma view chamada

vw_clientes_ativos com base na consulta SELECT fornecida.

o SELECT * FROM vw_clientes_ativos: Consulta os dados da view como se

fosse uma tabela real.

o A view vw_pedidos_clientes demonstra como uma view pode encapsular

uma consulta com JOIN para simplificar o acesso a dados relacionados.

Sugestões de Aplicabilidade Prática:

o Simplificar consultas complexas: Views podem abstrair a lógica de

consultas complexas, tornando as consultas dos usuários mais simples.

o Segurança: Permitem conceder acesso a dados específicos sem dar

acesso direto às tabelas base.

o Consistência: Garantem que diferentes usuários vejam os dados da

mesma forma, baseados na lógica definida na view.

Propostas de Exercícios Guiados:

1. Crie uma view que mostre apenas os produtos com preço superior a um
determinado valor.

2. Crie uma view que combine os nomes dos clientes com o número de pedidos que
cada um fez (isso envolverá GROUP BY e COUNT()).

3. Tente consultar a view criada e verificar os resultados.

4. (Se sua versão do MySQL suportar atualização de views) Tente atualizar dados
através de uma view e observe se as alterações se refletem nas tabelas base.

Erros Comuns e Boas Práticas: Erros comuns incluem criar views baseadas em
consultas muito complexas que podem prejudicar o desempenho, e tentar atualizar
views que não são atualizáveis devido à complexidade da consulta subjacente (por
exemplo, views envolvendo agregações ou GROUP BY).

Boas práticas incluem usar views para simplificar a lógica de consulta, documentar
o propósito das views, e testar o desempenho das consultas que utilizam views.

23
6. Joins

Explicações Detalhadas: Joins são usados para combinar linhas de duas ou mais
tabelas com base em uma coluna relacionada entre elas. A cláusula JOIN é usada na
parte FROM de uma instrução SELECT.

O tipo de JOIN especifica como as linhas serão combinadas. A condição de JOIN

(geralmente usando a cláusula ON) define como as linhas das tabelas envolvidas devem
corresponder. Os principais tipos de JOIN são:

o INNER JOIN (ou apenas JOIN): Retorna apenas as linhas quando há uma
correspondência em ambas as tabelas com base na condição de JOIN.

o LEFT OUTER JOIN (ou LEFT JOIN): Retorna todas as linhas da tabela
da esquerda e as linhas correspondentes da tabela da direita. Se não
houver correspondência na tabela da direita, as colunas da direita terão
valores NULL.

o RIGHT OUTER JOIN (ou RIGHT JOIN): Retorna todas as linhas da tabela
da direita e as linhas correspondentes da tabela da esquerda. Se não
houver correspondência na tabela da esquerda, as colunas da esquerda
terão valores NULL.

o FULL OUTER JOIN (ou FULL JOIN): Retorna todas as linhas de ambas
as tabelas. Se não houver correspondência entre as tabelas, as colunas
da tabela sem correspondência terão valores NULL. O suporte para FULL
OUTER JOIN pode variar entre SGBDs (o MySQL pode não ter suporte
direto em algumas versões, sendo necessário usar UNION com LEFT JOIN
e RIGHT JOIN para emular esse comportamento).

o CROSS JOIN: Retorna o produto cartesiano de todas as linhas de ambas

as tabelas (cada linha da primeira tabela é combinada com cada linha
da segunda tabela). Geralmente usado com uma cláusula WHERE para
filtrar os resultados.

o Você pode usar aliases para tabelas para tornar as consultas com JOIN
mais concisas.

Explicações Gráficas (Conceituais):

24
 o INNER JOIN: Imagine dois círculos sobrepostos. Um representa a tabela
A e o outro a tabela B. O INNER JOIN retorna a área onde os círculos se
sobrepõem (as linhas que existem em ambas as tabelas com base na
condição).

o LEFT OUTER JOIN: Retorna todo o círculo da tabela A e a parte

sobreposta com o círculo da tabela B. Se não houver sobreposição para
uma linha de A, as colunas de B serão NULL.

o RIGHT OUTER JOIN: Retorna todo o círculo da tabela B e a parte

sobreposta com o círculo da tabela A. Se não houver sobreposição para
uma linha de B, as colunas de A serão NULL.

o FULL OUTER JOIN: Retorna a união de ambos os círculos (toda a área

coberta pelos dois círculos). Se não houver sobreposição para uma linha
em uma das tabelas, as colunas da outra tabela serão NULL.

Exemplos Comentados: (Assumindo que temos as tabelas clientes e pedidos com uma
coluna comum cliente_id)

-- INNER JOIN: Seleciona os nomes dos clientes e os IDs dos seus pedidos

SELECT c.nome, p.id AS pedido_id

FROM clientes c
INNER JOIN pedidos p ON c.id = p.cliente_id;
FROM clientes c: Especifica a tabela clientes com o alias c.
INNER JOIN pedidos p ON c.id = p.cliente_id: Realiza um INNER JOIN com a tabela pedidos (alias p) onde a
coluna id da tabela clientes corresponde à coluna cliente_id da tabela pedidos.
O resultado conterá apenas os clientes que têm pedidos e os IDs desses pedidos.
-- LEFT OUTER JOIN: Seleciona todos os clientes e os IDs dos seus pedidos (se houver)
SELECT c.nome, p.id AS pedido_id
FROM clientes c
LEFT OUTER JOIN pedidos p ON c.id = p.cliente_id;
Retorna todos os clientes da tabela clientes. Se um cliente não tiver nenhum pedido na tabela pedidos, a
coluna pedido_id terá o valor NULL para esse cliente.
-- RIGHT OUTER JOIN: Seleciona todos os pedidos e os nomes dos clientes que os fizeram (se houver)
SELECT c.nome, p.id AS pedido_id
FROM clientes c
RIGHT OUTER JOIN pedidos p ON c.id = p.cliente_id;

25
 Retorna todos os pedidos da tabela pedidos. Se um pedido tiver um cliente_id que não corresponde a nenhum
id na tabela clientes, a coluna nome terá o valor NULL para esse pedido.
-- (Exemplo de CROSS JOIN - geralmente usado com WHERE)
SELECT c.nome, pr.nome AS nome_produto
FROM clientes c
CROSS JOIN produtos pr
WHERE c.id = 1; -- Adicionando uma condição para limitar o resultado (sem condição, seria o produto cartesiano
completo)
o Combina cada cliente com cada produto, e então filtra para mostrar
apenas as combinações para o cliente com id = 1.

Sugestões de Aplicabilidade Prática: Joins são essenciais para consultar dados

relacionados que estão armazenados em tabelas separadas, o que é uma prática
fundamental no design de bancos de dados relacionais para evitar redundância e
garantir a integridade dos dados.

Propostas de Exercícios Guiados:

1. Usando as tabelas clientes e pedidos, escreva uma consulta que retorne o nome de
cada cliente e o número total de pedidos que ele fez (isso envolverá JOIN e GROUP
BY).

2. Escreva uma consulta que liste todos os clientes e seus respectivos endereços
(assumindo que você tem uma tabela enderecos ligada a clientes). Use um LEFT
JOIN para garantir que todos os clientes sejam listados, mesmo que não tenham
um endereço registrado.

3. Crie uma terceira tabela chamada categorias e relacione-a com a tabela produtos.
Escreva uma consulta que retorne o nome do produto e o nome da sua categoria
usando um INNER JOIN.

Erros Comuns e Boas Práticas: Erros comuns incluem usar o tipo de JOIN incorreto,
esquecer ou definir incorretamente a condição de JOIN (na cláusula ON), o que
pode levar a resultados inesperados (como o produto cartesiano não intencional), e
não usar aliases para tabelas, o que pode tornar as consultas com múltiplos joins
difíceis de ler.

Boas práticas incluem compreender claramente o relacionamento entre as tabelas

que você está unindo, usar o tipo de JOIN apropriado para a sua necessidade (por
exemplo, use LEFT JOIN se você precisa de todos os registros da tabela da esquerda),
e sempre especificar a condição de JOIN usando a cláusula ON.

26
7. Funções (Functions)

Explicações Detalhadas: Funções em SQL são rotinas que aceitam argumentos de

entrada e retornam um valor. O MySQL oferece uma vasta gama de funções built-in
que podem ser usadas em cláusulas SELECT e WHERE para manipular dados, realizar
cálculos, formatar informações, trabalhar com datas e horas, e muito mais. Exemplos
incluem funções de agregação (COUNT(), AVG(), SUM(), MIN(), MAX()), funções de
string (CONCAT(), SUBSTRING(), UPPER(), LOWER(), TRIM()), funções numéricas (ABS(),
MOD(), ROUND(), SQRT()), e funções de data e hora (NOW(), DATE(), YEAR(), MONTH(),
DAY(), DATE_ADD(), DATE_SUB()).

Não deve haver espaço em branco entre o nome da função e os parênteses que a
seguem. O MySQL também permite a criação de Funções Definidas pelo Usuário
(UDFs), que são funções personalizadas implementadas em linguagens como C ou C++
e carregadas no servidor MySQL.

Para criar uma UDF, você precisa escrever o código na linguagem apropriada, compilá-
lo em uma biblioteca compartilhada e, em seguida, registrar a função no MySQL usando
o comando CREATE FUNCTION. Você precisa definir o nome da função, os tipos de
dados dos parâmetros de entrada e o tipo de dados do valor de retorno. O corpo da
função UDF conterá a lógica implementada no código compilado.

Exemplos Comentados:

-- Usando funções built-in

SELECT COUNT(*) FROM pedidos WHERE YEAR(data_pedido) = YEAR(NOW()); -- Conta o número de pedidos feitos no ano
atual
SELECT UPPER(nome) FROM clientes WHERE cidade = 'São Paulo'; -- Exibe os nomes dos clientes em maiúsculas
SELECT CONCAT(nome, ' (', email, ')') AS contato FROM clientes; -- Concatena nome e email para criar uma informação
de contato
SELECT AVG(preco) FROM produtos; -- Calcula o preço médio de todos os produtos

-- (Exemplo conceitual de criação de UDF - a implementação real envolveria C/C++)

-- Assumindo que criamos uma UDF chamada 'calcular_desconto' que recebe o preço e retorna o preço com desconto
-- CREATE FUNCTION calcular_desconto(preco DECIMAL) RETURNS DECIMAL
-- DETERMINISTIC
-- BEGIN
-- -- Lógica para calcular o desconto

27
 -- RETURN preco * 0.9;
-- END;

-- Usando a UDF (após ter sido criada e registrada)

-- SELECT nome, calcular_desconto(preco) AS preco_com_desconto FROM produtos;
o Os exemplos com funções built-in ilustram como usar funções para
realizar diversas operações nos dados durante a consulta.

o O exemplo conceitual de UDF mostra a ideia de estender a

funcionalidade do SQL com código personalizado. A criação real de UDFs
envolve etapas de programação e configuração mais complexas.

Sugestões de Aplicabilidade Prática:

o Funções built-in: Realizar cálculos complexos, formatar dados para

exibição, manipular strings, trabalhar com datas e horas diretamente
nas suas consultas SQL.

o UDFs: Implementar lógica de negócios específica que não pode ser

facilmente expressa em SQL, integrar funcionalidades externas (através
de bibliotecas C/C++).

• Propostas de Exercícios Guiados:

1. Use funções de data e hora para selecionar todos os pedidos feitos no mês
passado.

2. Use funções de string para exibir os nomes dos clientes com a primeira letra em
maiúscula e o restante em minúsculas.

3. Use funções numéricas para calcular o valor total de todos os produtos em

estoque (preço * estoque).

4. (Desafio avançado) Pesquise como criar uma UDF simples em MySQL (se você
tiver um ambiente de desenvolvimento configurado) e tente implementá-la e usá-la
em uma consulta.

Erros Comuns e Boas Práticas: Erros comuns incluem erros de sintaxe ao chamar
funções (esquecer parênteses, vírgulas), usar funções em tipos de dados incorretos,
e não entender o valor de retorno de uma função. Ao criar UDFs, erros podem ocorrer
na implementação do código, na compilação da biblioteca, ou no registro da função
no MySQL.

28
Boas práticas incluem consultar a documentação do MySQL para entender o uso e os
parâmetros de cada função built-in, usar aliases para tornar os resultados com
funções mais legíveis, e ter cuidado ao criar UDFs, garantindo que o código seja
seguro e eficiente. Note que stored FUNCTIONs não podiam conter referências a
tabelas em algumas versões do MySQL (incluindo algumas instruções SET mas excluindo
algumas instruções SELECT), mas essa limitação seria removida.

8. Procedures (Stored Procedures)

Explicações Detalhadas: Stored Procedures (ou procedimentos armazenados) são

conjuntos de comandos SQL que podem ser compilados e armazenados no servidor
do banco de dados. Uma vez criados, os clientes não precisam reenviar todos os
comandos individuais, mas podem simplesmente referenciar o stored procedure pelo
seu nome para executá-lo. Isso pode levar a um aumento no desempenho, pois a
consulta precisa ser analisada pelo servidor apenas uma vez e menos informações
precisam ser transferidas entre o servidor e o cliente.

Stored procedures também permitem encapsular lógica de negócios complexa

diretamente no banco de dados, podendo receber parâmetros de entrada (IN),
retornar parâmetros de saída (OUT), ou ambos (INOUT). A sintaxe básica para criar
uma stored procedure é CREATE PROCEDURE nome_procedimento ([parâmetro1 tipo1
[IN|OUT|INOUT], ...]) BEGIN instruções_sql; END;.

Para criar uma stored function (que retorna um valor), a sintaxe é CREATE FUNCTION
nome_funcao ([parâmetro1 tipo1, ...]) RETURNS tipo_retorno [características] BEGIN
instruções_sql; RETURN valor; END;. Stored procedures podem conter várias instruções
SQL, incluindo DDL (como CREATE e DROP) e instruções de transação (como COMMIT).
Para executar um stored procedure, use o comando CALL
nome_procedimento(argumentos);.

Para remover um stored procedure, use DROP PROCEDURE nome_procedimento;. Você

pode usar SHOW PROCEDURE STATUS para listar os stored procedures existentes.

Exemplos Comentados:

-- Exemplo de stored procedure com parâmetro IN

DELIMITER //
CREATE PROCEDURE sp_listar_clientes_por_cidade (IN cidade_param VARCHAR(50))

29
BEGIN
SELECT nome, email FROM clientes WHERE cidade = cidade_param;
END //
DELIMITER ;

-- Chamando a stored procedure

CALL sp_listar_clientes_por_cidade('São Paulo');

-- Exemplo de stored procedure com parâmetro OUT

DELIMITER //
CREATE PROCEDURE sp_contar_clientes (OUT total INT)
BEGIN
SELECT COUNT(*) INTO total FROM clientes;
END //
DELIMITER ;

-- Chamando a stored procedure e obtendo o parâmetro OUT

CALL sp_contar_clientes(@num_clientes);
SELECT @num_clientes;

-- Exemplo de stored function

DELIMITER //
CREATE FUNCTION sf_formatar_nome_email (nome VARCHAR(255), email VARCHAR(255))
RETURNS VARCHAR(512)
DETERMINISTIC
BEGIN
RETURN CONCAT(nome, ' <', email, '>');
END //
DELIMITER ;

-- Usando a stored function

SELECT sf_formatar_nome_email(nome, email) AS contato FROM clientes;

30
 -- Removendo os objetos criados

DROP PROCEDURE IF EXISTS sp_listar_clientes_por_cidade;

DROP PROCEDURE IF EXISTS sp_contar_clientes;
DROP FUNCTION IF EXISTS sf_formatar_nome_email;
o DELIMITER // ... END // DELIMITER ;: Altera temporariamente o
delimitador padrão (;) para permitir o uso de ; dentro do corpo da stored
procedure.

o O primeiro exemplo shows uma procedure que recebe uma cidade como
entrada e retorna os clientes dessa cidade.

o O segundo exemplo mostra uma procedure que calcula o número total

de clientes e retorna esse valor como um parâmetro de saída.

o O terceiro exemplo demonstrates a function that takes a name and

email as input and returns a formatted string.

o O comando CALL é usado para executar as stored procedures. Variáveis

de usuário (precedidas por @) podem ser usadas para receber os valores
dos parâmetros OUT.

Sugestões de Aplicabilidade Prática:

o Encapsular lógica de negócios: Implementar regras de negócios

complexas diretamente no banco de dados.

o Melhorar o desempenho: Reduzir o tráfego de rede entre a aplicação e

o banco de dados.

o Reutilização de código: Chamar a mesma lógica de diferentes partes da

aplicação.

o Segurança: Controlar o acesso aos dados através da execução de stored

procedures, em vez de permitir acesso direto às tabelas.

Propostas de Exercícios Guiados:

1. Crie uma stored procedure que receba o ID de um cliente como entrada e retorne
todos os seus pedidos.

2. Crie uma stored procedure que receba o nome de um produto e um valor de

desconto como entrada, e atualize o preço desse produto aplicando o desconto.

31
3. Crie uma stored function que receba uma data como entrada e retorne o dia da
semana por extenso (por exemplo, 'Segunda-feira').

4. Chame as stored procedures e stored functions criadas e verifique os resultados.

Erros Comuns e Boas Práticas: Erros comuns incluem erros de sintaxe na definição
da stored procedure ou function, não tratar corretamente os parâmetros de
entrada e saída, e criar stored procedures muito complexas que são difíceis de
manter.

Boas práticas incluem usar nomes descritivos para stored procedures e seus
parâmetros, documentar a finalidade e o uso de cada stored procedure, validar os
dados de entrada dentro da stored procedure, e manter as stored procedures
focadas em uma tarefa específica. Stored procedures aumentam a carga no servidor
de banco de dados, pois grande parte do trabalho é feita no servidor e menos no
cliente. É importante considerar esse impacto no desempenho.

9. Triggers

Explicações Detalhadas: Triggers (ou gatilhos) são blocos de código SQL que são
automaticamente executados (ou "disparados") em resposta a certos eventos que
ocorrem em uma tabela específica.

Os eventos que podem disparar um trigger geralmente incluem operações de INSERT,

UPDATE, ou DELETE em uma tabela. Você pode definir triggers para serem executados
antes (BEFORE) ou depois (AFTER) do evento.

Triggers são frequentemente usados para manter a integridade referencial (embora

as restrições FOREIGN KEY sejam a forma padrão), auditar alterações nos dados, gerar
valores automaticamente (em situações mais complexas do que AUTO_INCREMENT ou
DEFAULT), e implementar regras de negócios complexas. A sintaxe básica para criar
um trigger é CREATE TRIGGER nome_trigger {BEFORE|AFTER}
{INSERT|UPDATE|DELETE} ON nome_tabela FOR EACH ROW BEGIN instruções_sql;
END;.

Você pode usar as palavras-chave NEW e OLD dentro do trigger para referenciar os
novos e os antigos valores das linhas que estão sendo modificadas.

Exemplos Comentados:

32
 -- Exemplo de trigger AFTER INSERT para auditar novas inserções na tabela clientes

DELIMITER //
CREATE TRIGGER trg_clientes_after_insert
AFTER INSERT ON clientes
FOR EACH ROW
BEGIN
INSERT INTO auditoria_clientes (data_evento, tipo_evento, cliente_id, nome)
VALUES (NOW(), 'INSERT', NEW.id, NEW.nome);
END //
DELIMITER ;

-- Exemplo de trigger BEFORE UPDATE para garantir que o email esteja sempre em minúsculas
DELIMITER //
CREATE TRIGGER trg_clientes_before_update
BEFORE UPDATE ON clientes
FOR EACH ROW
BEGIN
SET NEW.email = LOWER(NEW.email);
END //
DELIMITER ;

-- Para remover os triggers

DROP TRIGGER IF EXISTS trg_clientes_after_insert;

DROP TRIGGER IF EXISTS trg_clientes_before_update;
o O primeiro exemplo cria um trigger que é executado após cada inserção
na tabela clientes. Ele insere um registro na tabela auditoria_clientes
com detalhes sobre o evento.

o O segundo exemplo cria um trigger que é executado antes de cada

atualização na tabela clientes. Ele converte o valor da coluna email para
minúsculas.

o FOR EACH ROW: Especifica que o trigger será executado para cada linha
afetada pelo evento.

33
 o NEW.id e NEW.nome: Referenciam os valores da coluna id e nome da
nova linha inserida.

o SET NEW.email = LOWER(NEW.email): Define o novo valor da coluna

email para sua versão em minúsculas antes da atualização.

Sugestões de Aplicabilidade Prática:

o Auditoria: Manter um histórico de alterações nos dados.

o Integridade dos dados: Garantir que certas regras sejam sempre

seguidas (como formatar dados consistentemente).

o Geração de dados derivados: Calcular e armazenar valores com base

em outras alterações.

Propostas de Exercícios Guiados:

1. Crie uma tabela de auditoria para a tabela produtos.

2. Crie um trigger que registre na tabela de auditoria sempre que um produto for
inserido, atualizado ou excluído, incluindo os dados relevantes (como o nome do
produto e o tipo de evento).

3. Crie um trigger que impeça a exclusão de clientes que possuem pedidos pendentes
(isso pode envolver verificar a existência de registros relacionados em outra
tabela).

Erros Comuns e Boas Práticas: Erros comuns incluem criar triggers que causam loops
infinitos (por exemplo, um trigger de atualização que dispara outro trigger de
atualização na mesma tabela), afetar negativamente o desempenho devido à
execução de lógica complexa em cada evento, e tornar a lógica do banco de dados
difícil de entender se houver muitos triggers com funcionalidades complexas.

Boas práticas incluem usar triggers com moderação, manter a lógica dos triggers
simples e focada em uma tarefa específica, documentar claramente o propósito e
o funcionamento de cada trigger, e considerar o impacto no desempenho.

10. Comandos SQL que Retornam o Número de

Linhas Afetadas

34
Explicações Detalhadas: Após a execução de comandos DML (Data Manipulation
Language) como INSERT, UPDATE, DELETE, e REPLACE, é frequentemente útil saber
quantas linhas foram afetadas pela operação. O MySQL fornece diferentes maneiras
de obter essa informação:

o Na saída do cliente mysql: Após executar um comando DML, o cliente

mysql geralmente exibe uma mensagem indicando o número de linhas
afetadas (por exemplo, "1 row affected").

o Função ROW_COUNT(): O MySQL fornece a função ROW_COUNT() que

retorna o número de linhas afetadas pela última instrução DML
executada na conexão atual.

o Função mysql_affected_rows() na API C: Se você estiver usando a API

C do MySQL, a função mysql_affected_rows() retorna o número de linhas
afetadas pela última consulta não-SELECT. Para consultas SELECT, essa
função retorna o número de linhas retornadas.

o Em algumas versões do MySQL, pode haver variáveis de sistema ou

funções similares para obter essa informação (verifique a documentação
da sua versão).

Exemplos Comentados:

-- Excluindo um cliente (assumindo que o cliente com ID 4 existe)

DELETE FROM clientes WHERE id = 4;

-- (A saída no cliente mysql provavelmente mostrará "1 row affected")

-- Selecionando o número de linhas afetadas usando ROW_COUNT()

SELECT ROW_COUNT(); -- Retornará 1 no caso do DELETE anterior

-- Inserindo um novo cliente

INSERT INTO clientes (nome, email) VALUES ('Maria Souza', '[email protected]');

SELECT ROW_COUNT(); -- Retornará 1

-- Atualizando vários clientes

UPDATE clientes SET ativo = 1 WHERE cidade = 'Rio de Janeiro';

SELECT ROW_COUNT(); -- Retornará o número de clientes no Rio de Janeiro que foram atualizados

35
 -- Tentando inserir um cliente com email duplicado (se a coluna 'email' for UNIQUE
e o registro já existir)

INSERT INTO clientes (nome, email) VALUES ('Novo Cliente', '[email protected]');

• SELECT ROW_COUNT(); -- Retornará 0 (se a inserção for ignorada devido à chave
duplicada) ou 1 (se REPLACE for usado e uma linha for substituída)

o ROW_COUNT() é chamada imediatamente após uma operação DML para

obter o número de linhas que foram modificadas ou excluídas.

Sugestões de Aplicabilidade Prática:

o Verificação de sucesso das operações: Usar ROW_COUNT() na sua

aplicação para confirmar se as operações de inserção, atualização ou
exclusão foram bem-sucedidas e quantas linhas foram afetadas.

o Lógica de controle de fluxo: Implementar lógica condicional na sua

aplicação com base no número de linhas afetadas.

o Auditoria e logging: Registrar o número de linhas alteradas por certas

operações.

Propostas de Exercícios Guiados:

1. Execute um comando INSERT e use ROW_COUNT() para verificar se uma linha foi
inserida.

2. Execute um comando UPDATE com uma cláusula WHERE que corresponda a várias
linhas e use ROW_COUNT() para verificar o número de linhas atualizadas.

3. Execute um comando DELETE e use ROW_COUNT() para verificar o número de linhas

excluídas.

4. Tente inserir um registro que viole uma restrição UNIQUE e observe o valor
retornado por ROW_COUNT().

Erros Comuns e Boas Práticas: Um erro comum é assumir que ROW_COUNT()

retornará sempre 1 para inserções bem-sucedidas (pode ser 0 se a inserção for
ignorada devido a INSERT IGNORE).

36
Boas práticas incluem chamar ROW_COUNT() imediatamente após a instrução DML
cuja contagem você deseja verificar, e interpretar o resultado corretamente com
base no tipo de operação e nas possíveis condições (como IGNORE ou REPLACE).

11. Outros Conceitos Importantes

Índices

Explicações: Índices são estruturas de dados especiais usadas para melhorar a

velocidade das operações de recuperação de dados (consultas SELECT).

Eles funcionam de forma semelhante aos índices de um livro, permitindo que o banco
de dados localize rapidamente as linhas que correspondem a uma determinada
condição, sem precisar examinar cada linha da tabela (table scan, que EXPLAIN pode
mostrar como ALL na coluna type, indicando uma busca completa na tabela).

Os índices são criados em uma ou mais colunas de uma tabela. Os tipos comuns de
índices incluem índices B-tree (usados na maioria dos casos), índices UNIQUE
(garantem que os valores em uma coluna sejam únicos), índices de texto completo
(FULLTEXT) para pesquisas textuais eficientes, e índices espaciais para dados
geográficos.

A criação de índices (CREATE INDEX nome_indice ON nome_tabela (coluna1, coluna2,

...);) e a exclusão (DROP INDEX nome_indice ON nome_tabela;) são operações DDL. A
criação de índices pode melhorar a performance das consultas de leitura, mas
também pode diminuir a performance das operações de escrita (INSERT, UPDATE,
DELETE) porque o índice precisa ser atualizado sempre que os dados da tabela são
modificados.

o Aplicabilidade: Use índices em colunas que são frequentemente usadas

em cláusulas WHERE (especialmente em consultas que são executadas
com frequência), em colunas usadas em cláusulas JOIN, e em colunas
usadas para ORDER BY.

o Exercícios: Crie índices nas colunas email da tabela clientes e nome da

tabela produtos. Use EXPLAIN antes de consultas que usam essas colunas
para observar se os índices estão sendo utilizados (a coluna key na saída

37
 de EXPLAIN indica o índice usado). Remova os índices usando DROP
INDEX.

o Erros e Boas Práticas: Não crie muitos índices em uma única tabela (isso
pode prejudicar o desempenho das operações de escrita). Crie índices
apenas nas colunas que realmente beneficiarão as suas consultas mais
importantes. Execute ANALYZE TABLE nome_tabela periodicamente
para atualizar as estatísticas da tabela, o que ajuda o otimizador do
MySQL a fazer melhores escolhas sobre quais índices usar.

Constraints (Restrições):

Explicações: Constraints são regras usadas para limitar o tipo de dados que podem
ser inseridos em uma tabela, garantindo a precisão e a confiabilidade dos dados
(integridade dos dados). Já vimos alguns exemplos:

▪ PRIMARY KEY: Identifica de forma única cada linha em uma

tabela. Uma tabela pode ter apenas uma chave primária.

▪ UNIQUE: Garante que todos os valores em uma coluna sejam

diferentes. Uma tabela pode ter várias restrições UNIQUE.

▪ NOT NULL: Garante que uma coluna não pode conter valores
NULL.

▪ FOREIGN KEY: Estabelece e impõe um link entre os dados em

duas tabelas, garantindo a integridade referencial. A tabela
contendo a chave estrangeira (tabela filha) referencia uma
coluna (geralmente a chave primária) de outra tabela (tabela
pai). As ações ON DELETE e ON UPDATE (como CASCADE,
RESTRICT, SET NULL) definem o que acontece com os registros
da tabela filha quando os registros correspondentes na tabela pai
são excluídos ou atualizados. O suporte completo a chaves
estrangeiras pode depender do tipo da tabela (InnoDB oferece
suporte completo).

▪ CHECK: Define uma condição que os valores em uma coluna

devem satisfazer. O suporte para CHECK constraints pode variar
em diferentes versões do MySQL. Constraints são definidas

38
 durante a criação da tabela (CREATE TABLE) ou podem ser
adicionadas ou removidas posteriormente usando ALTER TABLE.

Aplicabilidade: Use constraints para garantir a qualidade e a consistência dos seus

dados.

Exercícios: Crie tabelas com diferentes tipos de constraints. Tente inserir dados que
violem as constraints e observe os erros. Use ALTER TABLE para adicionar e remover
constraints.

Erros e Boas Práticas: Entenda o propósito de cada tipo de constraint e use-os

adequadamente para o seu modelo de dados. Ao trabalhar com chaves estrangeiras,
esteja ciente das implicações das ações ON DELETE e ON UPDATE.

Transações:

Explicações: Uma transação é uma sequência de uma ou mais operações SQL que
são tratadas como uma única unidade lógica de trabalho. As transações seguem o
modelo ACID:

Atomicidade: Todas as operações dentro de uma transação são concluídas com sucesso
(commit) ou todas são desfeitas (rollback). Não há um estado parcial.

Consistência: Uma transação leva o banco de dados de um estado consistente para

outro estado consistente.

Isolamento: As transações concorrentes devem operar de forma isolada umas das

outras. O grau de isolamento pode ser configurado (por exemplo, REPEATABLE READ é
o nível padrão no InnoDB).

Durabilidade: Uma vez que uma transação é confirmada (committed), suas alterações
são permanentes, mesmo em caso de falhas do sistema.

Para iniciar uma transação, use START TRANSACTION ou BEGIN. Para tornar as
alterações permanentes, use COMMIT. Para desfazer as alterações desde o início da
transação ou desde um savepoint, use ROLLBACK. Você pode definir pontos de
salvamento dentro de uma transação usando SAVEPOINT nome_ponto e reverter para
um ponto específico com ROLLBACK TO SAVEPOINT nome_ponto. O modo AUTOCOMMIT
(ligado por padrão) faz com que cada instrução SQL seja tratada como uma transação
individual. Você pode desativar o autocommit com SET AUTOCOMMIT = 0.

39
Aplicabilidade: Use transações para agrupar operações relacionadas que devem ser
tratadas como uma única unidade, como transferências bancárias (débito de uma conta
e crédito em outra). Isso garante que ambas as operações ocorram ou nenhuma delas
ocorra, mantendo a consistência dos dados.

Exercícios: Desative o autocommit, execute uma série de comandos INSERT e UPDATE,

e então use COMMIT. Repita o processo e use ROLLBACK em vez de COMMIT para ver
as alterações serem desfeitas. Experimente usar SAVEPOINT.

Erros e Boas Práticas: Não deixe transações abertas por muito tempo, pois isso pode
causar problemas de bloqueio e desempenho. Use transações para garantir a
integridade dos dados em operações complexas. Esteja ciente dos diferentes níveis de
isolamento de transação e escolha o apropriado para a sua aplicação.

Normalização Básica:

Explicações: Normalização é o processo de organizar os dados em um banco de dados

para reduzir a redundância e a dependência. O objetivo é evitar anomalias de
inserção, atualização e exclusão, que podem ocorrer quando os dados são repetidos
em várias tabelas.

Existem várias "formas normais" (1NF, 2NF, 3NF, etc.), cada uma com um conjunto
específico de regras. A normalização básica geralmente envolve dividir tabelas grandes
em tabelas menores e relacionadas, definindo relacionamentos entre elas através de
chaves primárias e estrangeiras.

Aplicabilidade: Aplique os princípios básicos de normalização ao projetar o esquema

do seu banco de dados para garantir a integridade e a eficiência do armazenamento
dos dados.

Exercícios: Considere um cenário com dados redundantes (por exemplo, uma tabela
de pedidos que inclui informações completas do cliente em cada pedido). Tente dividir
esses dados em tabelas separadas (clientes e pedidos) e definir um relacionamento
entre elas usando chaves primárias e estrangeiras.

Erros e Boas Práticas: Não exagere na normalização, pois muitas tabelas com muitos
joins podem impactar o desempenho das consultas. Encontre um equilíbrio entre a
normalização para a integridade dos dados e a desnormalização (em casos específicos
e justificados) para melhorar o desempenho de leitura.

40
Tabela de Referência Rápida dos Principais
Comandos SQL
Categoria Comando Descrição

DDL CREATE DATABASE nome; Cria um novo banco de dados.

DDL USE nome_db; Seleciona um banco de dados

para uso.

DDL CREATE TABLE nome (...); Cria uma nova tabela.

DDL ALTER TABLE nome ...; Modifica a estrutura de uma

tabela.

DDL DROP DATABASE nome; Exclui um banco de dados.

DDL DROP TABLE nome; Exclui uma tabela.

DDL RENAME TABLE antigo TO novo; Renomeia uma tabela.

DDL TRUNCATE TABLE nome; Remove todos os dados de uma

tabela (mantém a estrutura).

DML INSERT INTO nome (...) VALUES Adiciona novos registros a uma
(...); tabela.

DML SELECT colunas FROM tabela Recupera dados de uma ou mais

WHERE condição ORDER BY ... tabelas.
LIMIT ...;

DML UPDATE nome SET col=valor Modifica registros existentes em

WHERE condição; uma tabela.

DML DELETE FROM nome WHERE Remove registros de uma

condição; tabela.

Outros CREATE VIEW nome AS SELECT ...; Cria uma tabela virtual (view).

Outros DROP VIEW nome; Exclui uma view.

Outros CREATE INDEX nome ON tabela Cria um índice em uma coluna.

(col);

41
 Outros DROP INDEX nome ON tabela; Remove um índice.

Outros START TRANSACTION; Inicia uma transação.

Outros COMMIT; Confirma as alterações de uma

transação.

Outros ROLLBACK; Desfaz as alterações de uma

transação.

Funções COUNT(), AVG(), etc. Funções de agregação.

Funções UPPER(), SUBSTR(), etc. Funções de string.

Funções NOW(), DATE(), etc. Funções de data e hora.

Procedures CREATE PROCEDURE nome (...); Cria um procedimento

armazenado.

Procedures CALL nome(...); Executa um procedimento

armazenado.

Procedures DROP PROCEDURE nome; Exclui um procedimento

armazenado.

Triggers CREATE TRIGGER nome ...; Cria um gatilho (trigger).

Triggers DROP TRIGGER nome; Exclui um gatilho (trigger).

Info SHOW TABLES; Lista as tabelas no banco de

dados atual.

Info SHOW COLUMNS FROM nome; Exibe as colunas de uma tabela.

Info DESCRIBE nome; Sinônimo de SHOW COLUMNS.

Info EXPLAIN SELECT ...; Exibe o plano de execução de

uma consulta SELECT.

Info SELECT ROW_COUNT(); Retorna o número de linhas

afetadas pela última operação
DML.

Espero que esta sequência de aprendizado detalhada e progressiva seja útil para a sua
jornada no aprendizado de SQL com MySQL!

42
Referências
MySQL AB (2023). MySQL Reference Manual. On-line
MySQL AB (). Manual de Referência do MySQL 4.1. On-line
Apostilando (2001). Tutorial MySQL. On-line

43