SQL

O que é MySQL?
MySQL é um sistema de gerenciamento de banco de dados relacional
(RDBMS) amplamente utilizado em todo o mundo. É uma solução gratuita e de
código aberto, ideal tanto para pequenas aplicações quanto para grandes
sistemas empresariais.

Características Principais do MySQL

Gratuito e Open Source: O MySQL é distribuído sob a licença GPL,
permitindo uso gratuito e modificações no código fonte.
Multiplataforma: Funciona em diversos sistemas operacionais como
Windows, Linux, macOS, entre outros.
Alto Desempenho: Otimizado para velocidade e eficiência em operações
de leitura e escrita.
Escalável: Pode gerenciar desde pequenos bancos de dados até sistemas
com milhões de registros.
Seguro: Oferece recursos robustos de segurança, incluindo criptografia e
controle de acesso.

Conceitos Fundamentais
RDBMS (Sistema de Gerenciamento de Banco de Dados
Relacional)
Um RDBMS organiza dados em tabelas (relações) compostas por linhas e
colunas. Cada tabela representa uma entidade, e os dados são relacionados
através de chaves primárias e estrangeiras.

Estrutura Básica
Banco de Dados (Database): Container que armazena múltiplas tabelas
Tabela (Table): Estrutura que armazena dados em formato de linhas e
colunas
Linha (Row): Registro individual de dados

SQL 1
 Coluna (Column): Campo que define um tipo específico de dado

Exemplos Práticos com Código

1. Criando um Banco de Dados
O primeiro passo é criar um banco de dados onde armazenaremos nossas
tabelas:

CREATE DATABASE minha_loja;

USE minha_loja;

CREATE DATABASE cria um novo banco de dados e USE seleciona o banco

para uso.

2. Criando uma Tabela

Vamos criar uma tabela de clientes com informações básicas:

CREATE TABLE Customers (

CustomerID INT PRIMARY KEY AUTO_INCREMENT,
CustomerName VARCHAR(100) NOT NULL,
ContactName VARCHAR(100),
Country VARCHAR(50),
City VARCHAR(50),
Email VARCHAR(100)
);

Explicação dos elementos importantes:

INT: Tipo de dado numérico inteiro
PRIMARY KEY: Identifica unicamente cada registro na tabela
AUTO_INCREMENT: Incrementa automaticamente o valor a cada novo
registro
VARCHAR(n): Tipo de dado para texto com tamanho máximo n
NOT NULL: Campo obrigatório que não pode ser vazio

3. Inserindo Dados (INSERT)

Para adicionar registros na tabela:

SQL 2
 INSERT INTO Customers (CustomerName, ContactName, Country,
City, Email)
VALUES
('João Silva', 'João', 'Brasil', 'São Paulo', 'joao@ema
[Link]'),
('Maria Santos', 'Maria', 'Brasil', 'Rio de Janeiro',
'maria@[Link]'),
('Pedro Costa', 'Pedro', 'Portugal', 'Lisboa', 'pedro@e
[Link]');

INSERT INTO adiciona novos registros na tabela especificada.

4. Consultando Dados (SELECT)

O comando SELECT é usado para recuperar dados do banco:
Selecionar todos os registros:

SELECT * FROM Customers;

Selecionar colunas específicas:

SELECT CustomerName, Email FROM Customers;

Filtrar resultados com WHERE:

SELECT * FROM Customers

WHERE Country = 'Brasil';

WHERE permite filtrar registros baseado em condições específicas.

5. Ordenando Resultados (ORDER BY)

SELECT * FROM Customers
ORDER BY CustomerName ASC;

ORDER BY organiza os resultados. ASC = crescente, DESC = decrescente.

6. Atualizando Dados (UPDATE)

SQL 3
 Para modificar registros existentes:

UPDATE Customers
SET Email = '[Link]@[Link]', City = 'Campinas'
WHERE CustomerID = 1;

⚠️ IMPORTANTE: Sempre use WHERE no UPDATE, caso contrário TODOS os

registros serão atualizados!

7. Deletando Dados (DELETE)

DELETE FROM Customers
WHERE CustomerID = 3;

⚠️ CUIDADO: DELETE sem WHERE apaga TODOS os registros da tabela!

Operadores e Condições
Operadores Lógicos
-- AND: Todas as condições devem ser verdadeiras
SELECT * FROM Customers
WHERE Country = 'Brasil' AND City = 'São Paulo';

-- OR: Pelo menos uma condição deve ser verdadeira

SELECT * FROM Customers
WHERE City = 'São Paulo' OR City = 'Rio de Janeiro';

-- NOT: Inverte a condição

SELECT * FROM Customers
WHERE NOT Country = 'Brasil';

Operador LIKE (Busca por Padrões)

-- Busca nomes que começam com 'Jo'
SELECT * FROM Customers
WHERE CustomerName LIKE 'Jo%';

SQL 4
 -- Busca nomes que contêm 'Silva'
SELECT * FROM Customers
WHERE CustomerName LIKE '%Silva%';

-- Busca emails que terminam com '.com'

SELECT * FROM Customers
WHERE Email LIKE '%.com';

% representa qualquer sequência de caracteres.

Operador IN
SELECT * FROM Customers
WHERE Country IN ('Brasil', 'Portugal', 'Argentina');

IN verifica se o valor está em uma lista de opções.

Operador BETWEEN
SELECT * FROM Customers
WHERE CustomerID BETWEEN 1 AND 10;

BETWEEN seleciona valores dentro de um intervalo (incluindo os limites).

Funções Agregadas
COUNT, AVG, SUM, MIN, MAX
-- Contar total de clientes
SELECT COUNT(*) AS TotalClientes FROM Customers;

-- Contar clientes do Brasil

SELECT COUNT(*) AS ClientesBrasil
FROM Customers
WHERE Country = 'Brasil';

-- Exemplo com tabela de Pedidos

SELECT
COUNT(*) AS TotalPedidos,

SQL 5
 SUM(Valor) AS ValorTotal,
AVG(Valor) AS ValorMedio,
MIN(Valor) AS MenorValor,
MAX(Valor) AS MaiorValor
FROM Pedidos;

GROUP BY
GROUP BY agrupa registros com valores iguais em uma ou mais colunas:

SELECT Country, COUNT(*) AS TotalClientes

FROM Customers
GROUP BY Country
ORDER BY TotalClientes DESC;

HAVING
HAVING é usado para filtrar resultados agrupados (WHERE não funciona com
funções agregadas):

SELECT Country, COUNT(*) AS TotalClientes

FROM Customers
GROUP BY Country
HAVING COUNT(*) > 5;

JOINs - Relacionando Tabelas

JOINs permitem combinar dados de múltiplas tabelas. Vamos criar um exemplo
com duas tabelas relacionadas:

-- Tabela de Pedidos
CREATE TABLE Orders (
OrderID INT PRIMARY KEY AUTO_INCREMENT,
OrderDate DATE,
CustomerID INT,
Amount DECIMAL(10, 2),
FOREIGN KEY (CustomerID) REFERENCES Customers(CustomerI

SQL 6
 D)
);

INNER JOIN
INNER JOIN retorna apenas registros que têm correspondência em ambas as
tabelas:

SELECT
[Link],
[Link],
[Link],
[Link]
FROM Customers
INNER JOIN Orders ON [Link] = [Link]
ID;

LEFT JOIN
LEFT JOIN retorna todos os registros da tabela esquerda, mesmo sem
correspondência na direita:

SELECT
[Link],
[Link],
[Link]
FROM Customers
LEFT JOIN Orders ON [Link] = [Link]
D;

RIGHT JOIN
RIGHT JOIN retorna todos os registros da tabela direita:

SELECT
[Link],
[Link],
[Link]
FROM Customers

SQL 7
 RIGHT JOIN Orders ON [Link] = [Link]
ID;

Constraints (Restrições)
Constraints garantem a integridade dos dados:

NOT NULL
CREATE TABLE Products (
ProductID INT PRIMARY KEY,
ProductName VARCHAR(100) NOT NULL,
Price DECIMAL(10, 2) NOT NULL
);

NOT NULL garante que o campo não pode ficar vazio.

UNIQUE
CREATE TABLE Users (
UserID INT PRIMARY KEY,
Username VARCHAR(50) UNIQUE,
Email VARCHAR(100) UNIQUE
);

UNIQUE garante que não existam valores duplicados na coluna.

CHECK
CREATE TABLE Products (
ProductID INT PRIMARY KEY,
ProductName VARCHAR(100),
Price DECIMAL(10, 2),
CHECK (Price > 0)
);

CHECK valida se o valor atende a uma condição específica.

DEFAULT

SQL 8
 CREATE TABLE Orders (
OrderID INT PRIMARY KEY,
OrderDate DATE DEFAULT (CURRENT_DATE),
Status VARCHAR(20) DEFAULT 'Pendente'
);

DEFAULT define um valor padrão quando nenhum é fornecido.

Alterando Tabelas (ALTER TABLE)

Adicionar Coluna
ALTER TABLE Customers
ADD Phone VARCHAR(20);

Remover Coluna
ALTER TABLE Customers
DROP COLUMN Phone;

Modificar Coluna
ALTER TABLE Customers
MODIFY COLUMN Email VARCHAR(150);

Índices para Performance

Índices aceleram consultas em tabelas grandes:

-- Criar índice simples

CREATE INDEX idx_customer_name ON Customers(CustomerName);

-- Criar índice composto

CREATE INDEX idx_country_city ON Customers(Country, City);

SQL 9
 -- Remover índice
DROP INDEX idx_customer_name ON Customers;

Views (Visões)
Views são consultas salvas que funcionam como tabelas virtuais:

-- Criar uma view

CREATE VIEW ClientesBrasil AS
SELECT CustomerID, CustomerName, City, Email
FROM Customers
WHERE Country = 'Brasil';

-- Usar a view
SELECT * FROM ClientesBrasil;

-- Remover view
DROP VIEW ClientesBrasil;

Funções Úteis do MySQL

Funções de String
-- CONCAT: Concatenar strings
SELECT CONCAT(CustomerName, ' - ', City) AS ClienteInfo FRO
M Customers;

-- UPPER/LOWER: Converter para maiúsculas/minúsculas

SELECT UPPER(CustomerName) FROM Customers;

-- LENGTH: Tamanho da string

SELECT CustomerName, LENGTH(CustomerName) AS Tamanho FROM C
ustomers;

-- SUBSTRING: Extrair parte da string

SELECT SUBSTRING(CustomerName, 1, 5) AS PrimeiroNome FROM C
ustomers;

SQL 10
 Funções de Data
-- Data atual
SELECT CURDATE() AS DataAtual;

-- Data e hora atual

SELECT NOW() AS DataHoraAtual;

-- Extrair partes da data

SELECT
OrderDate,
YEAR(OrderDate) AS Ano,
MONTH(OrderDate) AS Mes,
DAY(OrderDate) AS Dia
FROM Orders;

-- Diferença entre datas

SELECT DATEDIFF(NOW(), OrderDate) AS DiasDesdeOrdem FROM Or
ders;

Funções Condicionais
-- CASE: Estrutura condicional
SELECT
CustomerName,
Country,
CASE
WHEN Country = 'Brasil' THEN 'Nacional'
WHEN Country IN ('Portugal', 'Argentina') THEN 'Amé
rica Latina'
ELSE 'Internacional'
END AS Categoria
FROM Customers;

-- IF: Condição simples

SELECT
ProductName,
Price,

SQL 11
 IF(Price > 100, 'Caro', 'Barato') AS Classificacao
FROM Products;

Transações
Transações garantem que um conjunto de operações seja executado
completamente ou não seja executado:

START TRANSACTION;

UPDATE Customers SET City = 'Brasília' WHERE CustomerID =

1;
INSERT INTO Orders (CustomerID, Amount) VALUES (1, 500.00);

-- Se tudo estiver correto:

COMMIT;

-- Ou, se houver erro:

ROLLBACK;

Boas Práticas
Sempre use WHERE em UPDATE e DELETE para evitar modificar/apagar
todos os registros
Use índices em colunas frequentemente pesquisadas para melhor
performance
Normalize seus dados para evitar redundância e inconsistências
Use transações para operações que precisam ser atômicas
Faça backups regulares do banco de dados
Use prepared statements para prevenir SQL Injection
Documente sua estrutura de banco de dados
Escolha tipos de dados apropriados para otimizar espaço e performance

Exemplo Completo de Projeto

Vamos criar um sistema simples de gerenciamento de biblioteca:

SQL 12
 -- Criar banco de dados
CREATE DATABASE biblioteca;
USE biblioteca;

-- Tabela de Autores
CREATE TABLE Autores (
AutorID INT PRIMARY KEY AUTO_INCREMENT,
Nome VARCHAR(100) NOT NULL,
Nacionalidade VARCHAR(50),
DataNascimento DATE
);

-- Tabela de Livros
CREATE TABLE Livros (
LivroID INT PRIMARY KEY AUTO_INCREMENT,
Titulo VARCHAR(200) NOT NULL,
AutorID INT,
AnoPublicacao INT,
ISBN VARCHAR(20) UNIQUE,
Preco DECIMAL(10, 2),
FOREIGN KEY (AutorID) REFERENCES Autores(AutorID)
);

-- Tabela de Membros
CREATE TABLE Membros (
MembroID INT PRIMARY KEY AUTO_INCREMENT,
Nome VARCHAR(100) NOT NULL,
Email VARCHAR(100) UNIQUE,
Telefone VARCHAR(20),
DataCadastro DATE DEFAULT (CURRENT_DATE)
);

-- Tabela de Empréstimos
CREATE TABLE Emprestimos (
EmprestimoID INT PRIMARY KEY AUTO_INCREMENT,
LivroID INT,
MembroID INT,
DataEmprestimo DATE DEFAULT (CURRENT_DATE),

SQL 13
 DataDevolucao DATE,
Status VARCHAR(20) DEFAULT 'Emprestado',
FOREIGN KEY (LivroID) REFERENCES Livros(LivroID),
FOREIGN KEY (MembroID) REFERENCES Membros(MembroID)
);

-- Inserir dados de exemplo

INSERT INTO Autores (Nome, Nacionalidade, DataNascimento) V
ALUES
('Machado de Assis', 'Brasil', '1839-06-21'),
('Clarice Lispector', 'Brasil', '1920-12-10'),
('José Saramago', 'Portugal', '1922-11-16');

INSERT INTO Livros (Titulo, AutorID, AnoPublicacao, ISBN, P

reco) VALUES
('Dom Casmurro', 1, 1899, '978-1234567890', 35.90),
('A Hora da Estrela', 2, 1977, '978-1234567891', 42.5
0),
('Ensaio sobre a Cegueira', 3, 1995, '978-1234567892',
48.00);

INSERT INTO Membros (Nome, Email, Telefone) VALUES

('Ana Silva', 'ana@[Link]', '11-98765-4321'),
('Carlos Santos', 'carlos@[Link]', '11-98765-4322');

-- Consultas úteis
-- Livros com informações do autor
SELECT
[Link],
[Link] AS Autor,
[Link],
[Link]
FROM Livros L
INNER JOIN Autores A ON [Link] = [Link];

-- Empréstimos ativos com detalhes

SELECT
[Link] AS Membro,

SQL 14
 [Link] AS Livro,
[Link],
[Link]
FROM Emprestimos E
INNER JOIN Membros M ON [Link] = [Link]
INNER JOIN Livros L ON [Link] = [Link]
WHERE [Link] = 'Emprestado';

-- Total de livros por autor

SELECT
[Link] AS Autor,
COUNT(*) AS TotalLivros,
AVG([Link]) AS PrecoMedio
FROM Autores A
LEFT JOIN Livros L ON [Link] = [Link]
GROUP BY [Link];

Recursos Adicionais
Para continuar aprendendo MySQL:
Pratique no MySQL Tutorial do W3Schools com o editor online
Explore os exercícios e quizzes disponíveis no site
Consulte a referência completa de funções e tipos de dados do MySQL
Experimente criar seus próprios projetos práticos
Lembre-se: A melhor forma de aprender SQL é praticando! Crie bancos de
dados, experimente comandos diferentes e analise os resultados.
explicação feita

SQL 15