SOBRE O MYSQL

O SQL foi desenvolvido originalmente nos laboratórios da IBM no início dos anos 70 e teve sua
maior performance quando a Oracle entrou no mercado.

A linguagem SQL veio com o objetivo de padronizar a forma como os dados são consultados
em banco de dados relacionais.

Podemos dizer que existem algumas vantagens ao aprender a linguagem SEQUEL onde a
primeira é padronização e o aprendizado.

O profissional que sabe SQL, por exemplo, da Oracle, facilmente vai utilizar o SQL server da
Microsoft, já que existem poucas diferenças da sintaxe usada, principalmente no que se diz
respeito às funções.

A portabilidade também é outro fator super relevante já que fica fácil se migrar do Mysql para
o Oracle, SQL server, ou vice-versa. Claro que essa portabilidade fica mais fácil quando se é
programador e faz o seu código mais próximo do ANSI (órgão americano) que formou padrões
para consultas de banco de dados relacionais no início dos anos 80.

Como existe um padrão na linguagem apenas como algumas diferenças, empresas acabam
optando por qual banco de dados usar a partir de critérios como performance, hardware,
custos e etc.

Apesar da padronização ser uma vantagem ela também nos trás uma desvantagem que é a
falta de criatividade e por isso banco de dados do tipo NOSQL acabaram surgindo e
principalmente por causa do BIG DATA que acaba englobando um oceano de informações que
também como origens as mídias sociais. Detalhe que acabam fugindo do padrão ANSI.

Esse padrão ANSI possui três grandes grupos de comando:

DDL – parte da linguagem que permite a manipulação da estrutura do banco de dados, como
criar o próprio, tabelas, índices, apagar e alterar política de crescimento do índice.

DML – responsável por gerenciar o banco de dados, como incluir, alterar, excluir informações
que estão dentro das estruturas do banco, como por exemplo as tabelas, claro que também
fazer as consultas e exibi-las aos usuários.

DCL – parte dos controles que permite toda a administração do banco de dados como controle
de acesso, gerenciamento de usuários, como vai ser feito seu armazenamento em disco, onde
será armazenado e assim por diante.

O MYSQL é interplataforma, ou seja, pode se desenvolver toda uma estrutura usando o

sistema operacional Windows e depois o migrar para Linux ou Unix por exemplo. Também é
acompanhado de diversas APIs que permitem acessar os dados do banco usando Java, Python
PHP e etc.
CURSO 1 E 2 MYSQL
Criando um banco de dados.
CREATE DATABASE SUCOS;

Ativando um Banco de dados.

USE SUCOS;

Apagando um banco de dados.

DROP DATABASE SUCOS;

Criando uma tabela.

CREATE TABLE tbclientes(
CPF VARCHAR(11),
NOME VARCHAR(100),
IDADE SMALLINT,
SEXO VARCHAR(1),
LIMITE_CREDITO FLOAT,
PRIMEIRA_COMPRA BIT(1));

Apagando uma tabela.

DROP TABLE tbclientes;

Inserindo registros na tabela.

INSERT INTO tbproduto ( PRODUTO, NOME, EMBALAGEM, TAMANHO, SABOR, PRECO_LISTA)
VALUES (‘1040107’, ‘Light – 350 ml – Melancia’, ‘Lata’, ‘350 ml’, ‘Melancia’, 4.56);

Selecionar todas as linhas ou registros de uma tabela.

SELECT * FROM tbproduto

Alterar algum campo dos registros.

UPDATE tbvendedores SET NOME = 'José Geraldo da Fonseca' WHERE MATRICULA = '00233';

Alterar mais de um campo de registro.

UPDATE tbvendedores SET DATA_ADMISSAO = '2013-09-17', DE_FERIAS = 1 WHERE
MATRICULA = '00236';

Apagando um registro da tabela.

DELETE FROM tbproduto WHERE PRODUTO = '1078680';

Atribuindo uma PRIMARY KEY a uma tabela existente.

ALTER TABLE tbprodutos ADD PRIMARY KEY (PRODUTO);
Adicionando uma nova coluna.
ALTER TABLE tbclientes ADD COLUMN (DATA_NASCIMENTO DATE);

Adicionando mais de uma coluna.

ALTER TABLE tbvendedores ADD COLUMN (DATA_ADMISSAO DATE, DE_FERIAS BIT);

Limitando a 5 registros nas consultas.

SELECT CPF, NOME FROM tbcliente LIMIT 5; ou LIMIT 0, 5; da pos. zero até os 5 próx. valores.

Atribuindo novos nomes.

SELECT CPF AS CPF_CLIENTE, NOME AS NOME_CLIENTE FROM tbcliente;

Alterar vários registros de uma vez com uma condição.

UPDATE tbproduto SET SABOR = ‘LARANJA’ WHERE SABOR = ‘LIMÃO’;

Selecionar registros onde a idade é diferente de 22 anos.

SELECT * FROM tbcliente WHERE idade <> 22;

Localizando um registro em um determinado intervalo | PRINCIPALMENTE EM PONTOS

FLUTANTES ONDE O SINAL DE IGUALDADE NÃO FUNCIONA!!!!!!!!!
SELECT * FROM tbproduto WHERE PRECO_LISTA BETWEEN 16.007 AND 16.009;

Selecionando datas.
SELECT * FROM tbcliente WHERE DATA_NASCIMENTO > ‘1995-01-13’;

Selecionando um ANO específico.

SELECT * FROM tbcliente WHERE YEAR(DATA_NASCIMENTO) > 1995;

Trabalhando com OR.

Select * from tbcliente WHERE CIDADE = 'Rio de Janeiro' OR CIDADE = 'São Paulo';

ERRO DE IMPORTAÇÃO? SUBSTITUA E APLIQUE COM:

ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_general_ci

Ou acesse a IDE DO Mysql Workbench, clique em FILE, RUN SQL SCRIPT, escolha o arquivo,
SELECIONE O BANCO e em seguida o tipo de DEFAULT CHARACTER SET e inicie a carga dos
dados.

Trabalhando com NOT.

SELECT * FROM tabela_de_produtos WHERE NOT (SABOR = ‘Manga’ AND TAMANHO = ‘470
ml’); a saída são todos os produtos que não possuem sabor manga de 470 ml.

SELECT * FROM tabela_de_produtos WHERE NOT (SABOR = ‘Manga’ OR TAMANHO = ‘470 ml’);
a saída são todos os produtos que não possuem sabor manga ou que tenham então a medida
de 470 ml.

SELECT NOME_DO_PRODUTO as PRODUTO, SABOR, TAMANHO FROM tabela_de_produtos

WHERE SABOR = 'Manga'
AND (TAMANHO = '350 ml' OR TAMANHO = '470 ml'); a saída são todos os produtos com sabor
manga que possuem medidas de 350 e 470 ml.
SELECT NOME_DO_PRODUTO as PRODUTO, SABOR, TAMANHO FROM tabela_de_produtos
WHERE SABOR = 'Manga' AND NOT (TAMANHO = '350 ml' OR TAMANHO = '470 ml'); a saída é
todos os produtos que possuem sabor manga e que não são do tamanho 350 ou 470 ml.

Trabalhando com IN.

SELECT * FROM tabela_de_produtos WHERE SABOR IN ('Manga', 'Uva'); a saída são os
produtos que apenas possuem sabores de manga ou então de uva.

Trabalhando com LIKE.

SELECT * FROM tabela_de_produtos WHERE SABOR LIKE '%Maçã%'; a saída será sabores do
tipo Maçã e Cereja/Maçã.

Trabalhando com DISTINCT.

SELECT DISTINCT EMBALAGEM FROM tabela_de_produtos; retorna PET, GARRAFA e LATA

SELECT DISTINCT EMBALAGEM, TAMANHO FROM tabela_de_produtos; pode acabar

retornando PET 400ML e PET 750ML, porque em combinações elas podem até se repetir, mas
quando usado o DISTINCT é apenas retornado um registro.

Trabalhando com ORDER BY ASC e DESC.

SELECT * FROM notas_fiscais ORDER BY IMPOSTO; do menor ao maior e se acrescentar DESC
depois de IMPOSTO teremos do maior para o menor.

Trabalhando com SUM, MAX, MIN, AVG, COUNT.

SELECT EMBALAGEM, COUNT (*) AS QUANTIDADE FROM tabela_de_produtos GROUP BY
EMBALAGEM DESC; o resultado é RJ 9500000 e SP 8100000.

SELECT EMBALAGEM, MAX(PRECO_DE_LISTA) AS PRECO_LISTA FROM tabela_de_produtos

GROUP BY EMBALAGEM ORDER BY PRECO_LISTA DESC; o resultado é Pet 38, Garrafa 13 e Lata
4.

SELECT EMBALAGEM, MAX(PRECO_DE_LISTA) AS PRECO_LISTA FROM tabela_de_produtos

GROUP BY EMBALAGEM ORDER BY PRECO_LISTA DESC; o final é de Pet 15, Garrafa 11 e Lata 5.

SELECT EMBALAGEM, MAX(PRECO_DE_LISTA) AS MAIOR_PRECO, MIN(PRECO_DE_LISTA) AS

MENOR_PRECO FROM
tabela_de_produtos GROUP BY EMBALAGEM; devolve as embalagens separadas por tipo e o
maior e menor preço de suas embalagens... referentes ao tamanho e material.
Quais foram os clientes que fizeram mais de 2 mil compras no ano de 2016?

select CPF, COUNT (*) FROM notas_fiscais WHERE YEAR(DATA_VENDA) = 2016 GROUP BY
CPF HAVING COUNT (*) > 2000 ORDER BY COUNT (*) DESC; primeiro selecionamos o cpf e a
quantidade de vezes que ele aparece, isso o retorno da um erro, então agrupamos por cpf e
fica ok. Em seguida filtramos por ano e em seguida usamos um HAVING “filtro extra” para
selecionar apenas os que tinham mais de 2 mil compras e os colocamos em ordem do maior
para o menor.

Trabalhando com CASE.

SELECT NOME_DO_PRODUTO, PRECO_DE_LISTA,
CASE
WHEN PRECO_DE_LISTA >= 12 THEN 'PRODUTO CARO'
WHEN PRECO_DE_LISTA >=7 AND PRECO_DE_LISTA < 12 THEN 'PRODUTO EM CONTA'
ELSE 'PRODUTO BARATO'
END AS STATUS_PRECO
FROM tabela_de_produtos;
Resultado = sabor da montanha, 6.3, produto barato

SELECT EMBALAGEM,
CASE
WHEN PRECO_DE_LISTA >= 12 THEN 'PRODUTO CARO'
WHEN PRECO_DE_LISTA >=7 AND PRECO_DE_LISTA < 12 THEN 'PRODUTO EM CONTA'
ELSE 'PRODUTO BARATO'
END AS STATUS_PRECO, AVG(PRECO_DE_LISTA) AS PRECO_MEDIO
FROM tabela_de_produtos WHERE SABOR = 'Manga' GROUP BY EMBALAGEM,
CASE
WHEN PRECO_DE_LISTA >= 12 THEN 'PRODUTO CARO'
WHEN PRECO_DE_LISTA >=7 AND PRECO_DE_LISTA < 12 THEN 'PRODUTO EM CONTA'
ELSE 'PRODUTO BARATO'
END;
Resultado = Garrafa, produto barato, 5.17 | Garrafa, produto em conta, 7.7 | Lata... etc. TUDO
sobre sabor MANGA!

SELECT NOME, IDADE, SEXO,

CASE
WHEN YEAR(DATA_DE_NASCIMENTO) < 1990 THEN 'PESSOA VELHA'
WHEN YEAR(DATA_DE_NASCIMENTO) >= 1990 AND YEAR(DATA_DE_NASCIMENTO) < 1995
THEN 'PESSOA JOVEM'
ELSE 'UMA CRIANÇA' ... até o fim do código.

Trabalhando com INNER JOIN.

SELECT * FROM tabela_de_vendedores A INNER JOIN notas_fiscais B ON A. MATRICULA = B.
MATRICULA; devolve todos os campos que possuem chaves correspondentes.

SELECT A. MATRICULA, A. NOME, COUNT (*) FROM

tabela_de_vendedores A INNER JOIN notas_fiscais B
ON A. MATRICULA = B. MATRICULA GROUP BY A. MATRICULA; devolve a quantidade de notas
fiscais lançadas por vendedor, no caso devolve 3 vendedores.

SELECT A. MATRICULA, A. NOME, YEAR(DATA_VENDA), COUNT (*) AS EMITIDAS FROM

tabela_de_vendedores A INNER JOIN notas_fiscais B
ON A. MATRICULA = B. MATRICULA GROUP BY A. MATRICULA, YEAR(DATA_VENDA);

SELECT YEAR(DATA_VENDA), SUM (QUANTIDADE * PRECO) AS FATURAMENTO

FROM notas_fiscais NF INNER JOIN itens_notas_fiscais INF
ON NF. NUMERO = INF.NUMERO
GROUP BY YEAR(DATA_VENDA); devolve o total de faturamento por ano.

LEFT JOIN.
SELECT DISTINCT A.CPF, A. NOME, B.CPF FROM tabela_de_clientes A LEFT JOIN
notas_fiscais B ON A.CPF = B.CPF WHERE B.CPF IS NULL;

SELECT DISTINCT A.CPF, A. NOME, B.CPF FROM tabela_de_clientes A LEFT JOIN

notas_fiscais B ON A.CPF = B.CPF WHERE B.CPF IS NULL;

SELECT DISTINCT A.CPF, A. NOME, B.CPF FROM tabela_de_clientes A LEFT JOIN

notas_fiscais B ON A.CPF = B.CPF WHERE NOT (B.CPF IS NULL); mesma coisa que um INNER
JOIN.

RIGHT JOIN.
SELECT DISTINCT A.CPF, A. NOME, B.CPF FROM notas_fiscais A LEFT JOIN
tabela_de_clientes B ON A.CPF = B.CPF WHERE B.CPF IS NULL; somente inverti as ordens das
tabelas para um exemplo prático.

SELECT A.NOME, A.BAIRRO, B.NOME, B.BAIRRO FROM tabela_de_vendedores A RIGHT JOIN

tabela_de_clientes B ON
A.BAIRRO = B.BAIRRO;

SELECT A.NOME, A.BAIRRO, B.NOME, B.BAIRRO FROM tabela_de_vendedores A RIGHT JOIN

tabela_de_clientes B ON
A.BAIRRO = B.BAIRRO WHERE A.BAIRRO IS NULL;
Trabalhando com UNION
SELECT BAIRRO FROM tabela_de_clientes
UNION
SELECT BAIRRO FROM tabela_de_vendedores; une os bairros sem repetição.

SELECT BAIRRO FROM tabela_de_clientes

UNION ALL
SELECT BAIRRO FROM tabela_de_vendedores; une os bairros com repetição.

SELECT BAIRRO, NOME,'CLIENTE' AS TIPO FROM tabela_de_clientes

UNION
SELECT BAIRRO, NOME, 'VENDEDOR' AS TIPO FROM tabela_de_vendedores;

SELECT BAIRRO, NOME, 'CLIENTE' AS TIPO, CPF AS IDENTIFICADOR FROM tabela_de_clientes

UNION
SELECT BAIRRO, NOME, 'VENDEDOR' AS TIPO, MATRICULA FROM tabela_de_vendedores;
Trabalhando com SUB CONSULTAS.
SELECT X. EMBALAGEM, X. PRECO_MAXIMO FROM
(SELECT EMBALAGEM, MAX(PRECO_DE_LISTA) AS PRECO_MAXIMO
FROM tabela_de_produtos GROUP BY EMBALAGEM) X WHERE X. PRECO_MAXIMO >= 5.0;

Trabalhando com VIEW.

SELECT * FROM vw_maiores_embalagens;

SELECT A. NOME_DO_PRODUTO, A. EMBALAGEM, A. PRECO_DE_LISTA, X. MAIOR_PRECO,

((A. PRECO_DE_LISTA / X. MAIOR_PRECO) -1) * 100 AS PERCENTUAL
FROM tabela_de_produtos A INNER JOIN vw_maiores_embalagens X ON
A.EMBALAGEM = X.EMBALAGEM;

Trabalhando com MANIPULAÇÃO DE TEXTO e DATA – FUNÇÕES MYSQL.

SELECT NOME, CONCAT (ENDERECO_1, ' ', BAIRRO, ' ', CIDADE, ' ', ESTADO) AS ENDEREÇO
FROM tabela_de_clientes;

SELECT DATEDIFF (CURRENT_TIMESTAMP (), '1997-12-02') AS RESULTADO; devolve a

quantidade de dias que eu já vivi.

SELECT DISTINCT DATA_VENDA, DAYNAME(DATA_VENDA) AS DIA,

MONTHNAME(DATA_VENDA) AS MÊS, YEAR(DATA_VENDA) AS ANO FROM notas_fiscais;
devolve a data, o nome do dia, do mês e do ano em inglês!

SELECT NOME, TIMESTAMPDIFF (YEAR, DATA_DE_NASCIMENTO, CURDATE ()) AS IDADE FROM

tabela_de_clientes; devolve a idade atual de todos os clientes.

CURSO 3 MYSQL
Criando um banco de dados.
CREATE DATABASE IF NOT EXIST vendas_sucos DEFAULT CHARACTER SET UTF-8;

Deletando um banco de dados.

DROP DATABASE IF EXIST vendas_sucos;
Criando uma tabela com PK.
CREATE TABLE clientes (
CPF varchar(11) NOT NULL,
NOME varchar(100) DEFAULT NULL,
ENDERECO varchar(150) DEFAULT NULL,
BAIRRO varchar(50) DEFAULT NULL,
CIDADE varchar(50) DEFAULT NULL,
ESTADO varchar(45) DEFAULT NULL,
CEP varchar(8) DEFAULT NULL,
DATA_NASCIMENTO date DEFAULT NULL,
IDADE int(11) DEFAULT NULL,
SEXO varchar(1) DEFAULT NULL,
LIMITE_CREDITO float DEFAULT NULL,
VOLUME_COMPRA float DEFAULT NULL,
PRIMEIRA_COMPRA bit(1) DEFAULT NULL,
PRIMARY KEY (CPF)) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

CREATE TABLE notas(

NUMERO varchar(5) NOT NULL,
DATA_VENDAS date NULL,
CPF varchar(11) NOT NULL,
MATRICULA varchar(5) NOT NULL,
IMPOSTO float NULL,
PRIMARY KEY (NUMERO))ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

Alterando o nome de uma coluna.

ALTER TABLE notas CHANGE DATA_VENDAS DATA_VENDA date NULL;

Criando um relacionamento entre a coluna CPF FK “Chave-estrângeira” de notas com a CPF

PK Da tabela clientes.
ALTER TABLE notas ADD CONSTRAINT FK_CLIENTES
FOREIGN KEY (CPF) REFERENCES clientes (CPF);

Inserindo vários valores ao mesmo tempo.

INSERT INTO clientes
(CPF,NOME,ENDERECO,BAIRRO,CIDADE,ESTADO,CEP,DATA_NASCIMENTO,IDADE,SEXO,LIMITE
_CREDITO,VOLUME_COMPRA,PRIMEIRA_COMPRA)
VALUES
('1471156710','Érica Carvalho','R. Iriquitia','Jardins','São
Paulo','SP','80012212','19900901',27,'F',170000,24500,0),
('19290992743','Fernando Cavalcante','R. Dois de Fevereiro','Água Santa','Rio de
Janeiro','RJ','22000000','20000212',18,'M',100000,20000,1);

Inserindo valores na tabela atual com dados de uma outra tabela de um outro banco de
dados, onde os dados já transferidos que já estão contidos na tabela não sejam perdidos.
INSERT INTO produtos
SELECT CODIGO_DO_PRODUTO AS CODIGO, NOME_DO_PRODUTO AS DESCRITOR, SABOR,
TAMANHO, EMBALAGEM,
PRECO_DE_LISTA AS PRECO_LISTA FROM sucos_vendas.tabela_de_produtos
WHERE CODIGO_DO_PRODUTO NOT IN (SELECT CODIGO FROM vendas_sucos.produtos);
Alterando valores de um registro específico.
UPDATE produtos SET EMBALAGEM = 'PET', TAMANHO = '1 litro', DESCRITOR = 'Sabor da
Montanha - 1 Litro - Uva' WHERE CODIGO = '1000889';

Alterando vários valores de uma coluna com um filtro em outra coluna.

UPDATE produtos SET PRECO_LISTA = PRECO_LISTA * 1.10 WHERE SABOR = 'Maracujá';

Alterando valores de uma coluna específica com uso de dados em lote de uma outra tabela
de um outro banco de dados.
UPDATE vendedores A INNER JOIN sucos_vendas.tabela_de_vendedores B
ON A.MATRICULA = substring(B.MATRICULA, 3, 3)
SET A.FERIAS = B.DE_FERIAS;

Alterando valores de uma coluna baseado em dados de lote de uma outra tabela de outro
banco de dados onde os campos específicos são os bairros.
UPDATE clientes A INNER JOIN vendedores B ON A.BAIRRO = B.BAIRRO
SET VOLUME_COMPRA = VOLUME_COMPRA * 1.30;

Uma forma de apagar e sincronizar duas tabelas.

DELETE FROM produtos WHERE
CODIGO NOT IN ( SELECT CODIGO_DO_PRODUTO FROM sucos_vendas.tabela_de_produtos);

Deletando todos os registros de uma tabela.

DELETE FROM itens_notas;

Iniciando uma TRANSACTION onde tudo que é feito é descartado.

START TRANSACTION
.
.
ROLLBACK;

Iniciando uma TRANSACTION onde tudo que é feito é confirmado.

STAR TRANSACTION
.
.
COMMIT;

Trabalhando com AUTOINCREMENT.

CREATE TABLE identificador (ID INT AUTO_INCREMENT, ALUNO VARCHAR (50), PRIMARY
KEY(ID));

NOTA IMPORTANTE: Na criação de duas tabelas onde uma é nota fiscal e uma outra onde se
tem o detalhes tais como o código do produto, seu preço e quantidade vendida, é importante
informar que apenas a primeira tabela tem uma PK e depois informar em uma query a
seguinte informação: onde itens_notas faz referente ao FK da tabela notas! IMPORTANTE!

ALTER TABLE itens_notas ADD CONSTRAINT FK_NUMERO FOREIGN KEY (NUMERO)

REFERENCES notas (NUMERO)
Trabalhando com TRIGGERS. ONDE PODE-SE TER PARA UPDATE E DELETE.

DELIMITER //
CREATE TRIGGER tg_calcula_faturamento_insert AFTER INSERT ON itens_notas
FOR EACH ROW BEGIN
DELETE FROM tab_faturamento;
INSERT INTO tab_faturamento
SELECT A.DATA_VENDA, SUM(B.QUANTIDADE * B.PRECO) AS TOTAL_VENDA FROM
notas A INNER JOIN itens_notas B ON A.NUMERO = B.NUMERO GROUP BY A.DATA_VENDA;
END //

Exemplo:
CREATE TRIGGER tg_calcula_faturamento_update AFTER UPDATE ON itens_notas
CREATE TRIGGER tg_calcula_faturamento_delete AFTER DELETE ON itens_notas

CURSO 4 MYSQL
Trabalhando com Procedures – Exemplo 1.
USE `sucos_vendas`;
DROP procedure IF EXISTS `oi_mundo_2`;

DELIMITER $$
USE `sucos_vendas`$$
CREATE PROCEDURE `oi_mundo_2`()
BEGIN
SELECT 'Oi Mundo! Estou aqui pela segunda vez!' AS MENSAGEM;
END$$

Apagando uma Procedure.

DROP procedure IF EXISTS `oi_mundo_2`;

Exemplo 2.
USE `sucos_vendas`$$
CREATE PROCEDURE `data_local` ()
BEGIN
declare ts datetime default localtimestamp();
select ts;
END$$

call data_local;
Exemplo 3.
USE sucos_vendas;
DROP procedure IF EXISTS `Exerc01`;

DELIMITER $$
USE `sucos_vendas`$$
CREATE PROCEDURE `Exerc01`()
BEGIN
DECLARE Cliente VARCHAR(10);
DECLARE Idade INT;
DECLARE DataNascimento DATE;
DECLARE Custo FLOAT;

SET Cliente = 'João';

SET Idade = 10;
SET DataNascimento = '20170110';
SET Custo = 10.23;

SELECT Cliente;
SELECT Idade;
SELECT DataNascimento;
SELECT Custo;
END $$

call Exerc01;

Exemplo 04 usando IF THEN ELSEIF.

CREATE DEFINER=`root`@`localhost` PROCEDURE `Testa_Numero_Notas`(DATANOTA date)

BEGIN
DECLARE NUMNOTAS INT;
SELECT COUNT(*) INTO NUMNOTAS FROM NOTAS_FISCAIS WHERE DATA_VENDA =
DATANOTA;
IF NUMNOTAS > 70 THEN
SELECT 'Muita Nota', NUMNOTAS;
ELSE
SELECT 'Pouca Nota', NUMNOTAS;
END IF;
END

call Testa_Numero_Notas ('20150101');

NOTA: as condições IF podem ser alteradas para CASE, segue o exemplo aplicado:

DECLARE msgdevolve VARCHAR(30)

CASE
WHEN NUMNOTAS > 70 THEN SET msgdevolve = ‘Muita Nota’;
ELSE
Msgdevolve = ‘Pouca Nota’;
END CASE;
Exemplo 05 Usando IF THEN ELSEIF.

CREATE DEFINER=`root`@`localhost` PROCEDURE `Comparativo_Vendas`(DataInicial DATE,

DataFinal DATE)
BEGIN
DECLARE FaturamentoInicial FLOAT;
DECLARE FaturamentoFinal FLOAT;
DECLARE Variacao float;

SELECT SUM(B.QUANTIDADE * B.PRECO) INTO FaturamentoInicial FROM NOTAS_FISCAIS A

INNER JOIN ITENS_NOTAS_FISCAIS B ON A.NUMERO = B.NUMERO
WHERE A.DATA_VENDA = DataInicial;

SELECT SUM(B.QUANTIDADE * B.PRECO) INTO FaturamentoFinal FROM NOTAS_FISCAIS A

INNER JOIN ITENS_NOTAS_FISCAIS B ON A.NUMERO = B.NUMERO
WHERE A.DATA_VENDA = DataFinal ;

SET Variacao = ((FaturamentoFinal / FaturamentoInicial) -1) * 100;

IF Variacao > 10 THEN
SELECT 'Verde';
ELSEIF Variacao >= -10 AND Variacao <= 10 THEN
SELECT 'Amarelo';
ELSE
SELECT 'Vermelho';
END IF;

END

call Comparativo_Vendas ('20150101', '20150102');

Exemplo 6 Trabalhando com LOOPING WHILE.

CREATE PROCEDURE `looping_while` (vNumInicial INT, vNumFinal INT)

BEGIN
DECLARE vContador INT;
DELETE FROM TAB_LOOPING;

SET vContador = vNumInicial;

WHILE vContador <= vNumFinal
DO
INSERT INTO TAB_LOOPING (ID) VALUES (vContador);
SET vContador = vContador + 1;
END WHILE;
SELECT * FROM TAB_LOOPING;
END

Call looping_while(1, 10); sua saída será 10 registros contendo em cada um número, 1, 2...10.

Exemplo 7 Desenvolvendo uma nova Procedure.

CREATE DEFINER=`root`@`localhost` PROCEDURE `acha_sabor_produto`(vPRODUTO

VARCHAR(50))
BEGIN
DECLARE vSabor VARCHAR(50);
SELECT SABOR INTO vSabor from tabela_de_produtos WHERE CODIGO_DO_PRODUTO =
vPRODUTO;
SELECT vSabor;
END

call acha_sabor_produto('1000889');

Trabalhando com a criação de uma NOVA FUNÇÃO.

SET GLOBAL log_bin_trust_function_creators = 1;

CREATE DEFINER=`root`@`localhost` FUNCTION `f_acha_tipo_sabor`(vSabor VARCHAR(50))

RETURNS varchar(20) CHARSET utf8mb4
BEGIN
DECLARE vRetorno VARCHAR(20) DEFAULT ' ';
CASE vSabor
WHEN 'Lima/Limão' THEN SET vRetorno = 'Cítrico';
WHEN 'Laranja' THEN SET vRetorno = 'Cítrico';
WHEN 'Morango/Limão' THEN SET vRetorno = 'Cítrico';
WHEN 'Uva' THEN SET vRetorno = 'Neutro';
WHEN 'Morango' THEN SET vRetorno = 'Neutro';
ELSE SET vRetorno = 'Ácido';
END CASE;
RETURN vRetorno;
END

SELECT f_acha_tipo_sabor('Laranja'); a saída é Cítrico

SELECT NOME_DO_PRODUTO, SABOR, f_acha_tipo_sabor(SABOR) from tabela_de_produtos;
CURSO 5 MYSQL
Puxando e alterando valores de variáveis globais do Mysql.

SHOW GLOBAL STATUS LIKE 'Created_tmp_disk_tables'; devolve a quantidade de tabelas

temporárias gravadas e lidas em disco.

SHOW GLOBAL STATUS LIKE 'Created_tmp_tables'; devolve a quantidade de tabelas gravadas

em memória

SHOW GLOBAL VARIABLES LIKE 'tmp_table_size'; devolve a quantidade máxima de dados em

bytes reservados para gravação de tabelas temporárias em memória.

SET GLOBAL tmp_table_size = 100000000; altera a quantidade do espaço reservado em bytes

para gravação de tabelas temporárias em bytes.

Verificar onde os bancos de dados estão sendo salvos.

select @@datadir;

Fazendo o BACKUP do banco de dados via prompt de comando.

CD/ para voltar ai diretório C

CD xampp
CD mysql
CD bin
Mysql dump -uroot -p –databases sucos_vendas >
C:\nomedapastaondevaisalvar\backupsucos.sql
SENHA: vazia no meu caso

BACKUP apenas de uma única tabela ou mais.

mysqldump -uroot -p --databases sucos_vendas --tables tabela_de_clientes >

C:\recuperacao\backup_tabela_de_clientes.sql

Trancando e Destrancando o banco de dados para o processo de BACKUP.

LOCK INSTANCE FOR BACKUP;

UNLOCK INSTANCE;

Realizando a carga dos dados do backup para dentro do MySQL.

mysql -uroot -p < C:\recuperacao\backup30122020.sql

LEMBRAR DE ABRIR O ARQUIVO E ALTERAR A VERSÃO DO MARIA DB PARA QUE NÃO

OCORRA ERRO!
Trabalhando com índices e seus custos.

SELECT * FROM notas_fiscais WHERE DATA_VENDA = '20170101'; devolve 74 registos a um

custo de 0.422 sec.

APLICANDO O INDEX.

ALTER TABLE notas_fiscais ADD INDEX (DATA_VENDA); aplicando-se a consulta acima

novamente se tem um custo de 0.031 sec.

TIRANDO O INDEX.

ALTER TABLE notas_fiscais DROP INDEX DATA_VENDA;

CRIANDO E APAGANDO UM USÁRIO ADMINISTRADOR.

CREATE USER 'admin01'@'localhost' IDENTIFIED BY 'admin01';

GRANT ALL PRIVILEGES ON *.* TO 'admin01'@'localhost' WITH GRANT OPTION;

DROP USER 'admin01'@'localhost';

CRIANDO UM USUÁRIO NORMAL.

CREATE USER 'auser01'@'localhost' IDENTIFIED BY 'user01';

GRANT SELECT, UPDATE, INSERT, DELETE, CREATE TEMPORARY TABLES, LOCK TABLES,
EXECUTE ON *.* TO 'user01'@'localhost' WITH GRANT OPTION;

CRIANDO UM USUÁRIO APENAS PARA BACKUP.

CREATE USER 'back01'@'localhost' IDENTIFIED BY 'back01';

GRANT SELECT, RELOAD, LOCK TABLES, REPLICATION CLIENT ON *.* TO 'back01'@'localhost'
WITH GRANT OPTION;

CRIANDO UM USUÁRIO APENAS PARA LEITURA.

CREATE USER 'read01'@'localhost' IDENTIFIED BY ' read01';

GRANT SELECT, EXECUTE ON *.* TO ' read01'@'localhost' WITH GRANT OPTION;

CRIANDO USUÁRIO PARA SE LOGAR DE QUALQUER LUGAR.

CREATE USER 'admin02'@'%' IDENTIFIED BY 'admin02';

GRANT ALL PRIVILEGES ON *.* TO 'admin02'@'%' WITH GRANT OPTION;

CRIANDO USUÁRIO PARA SE CONECTAR A APENAS UM SCHEMA.

CREATE USER 'user02'@'%' IDENTIFIED BY 'user02';

GRANT SELECT, INSERT, UPDATE, DELETE, LOCK TABLES, CREATE TEMPORARY TABLES,
EXECUTE ON sucos_vendas.* TO 'user02'@'%';

CRIANDO USUÁRIO APENAS PARA SE CONECTAR A UM SCHEMA E DUAS TABELAS COM

PRIVILÉGIOS DIFERENTES ENTRE ELAS.
CREATE USER 'user03'@'%' IDENTIFIED BY 'user03';
GRANT SELECT, INSERT, UPDATE, DELETE
ON sucos_vendas.tabela_de_clientes TO 'user03'@'%';
GRANT SELECT
ON sucos_vendas.tabela_de_produtos TO 'user03'@'%';

VERIFICANDO TODOS OS USUÁRIOS EXISTENTES NO BANCO DE DADOS.

SELECT * FROM mysql.user;

VERIFICANDO O PRIVILÉGIO DE UM USUÁRIO.

SHOW GRANTS FOR 'user02'@'%';

REMOVENDO PRIVILÉGIOS DO USUÁRIO USER02.

REVOKE ALL PRIVILEGES, GRANT OPTION FROM 'user02'@'%';

NORMALIZAÇÃO
DOS DADOS
CRIADO UMA TABELA JÁ COM O ÍNDICE.

CREATE TABLE livros(

Id INTEGER primary key auto_increment not null,
nome VARCHAR(100) not null,
lancamento DATE not null,
INDEX indice_por_lancamento (lancamento),
autor_id INTEGER not null
);

ATRIBUINDO UM ÍNDICE A UMA COLUNA.

CREATE INDEX indice_por_lancamento on livros(lancamento);

VERIFICANDO OS INDEX DE UMA TABELA.

SHOW INDEX FROM livros;

APAGANDO UM INDEX.

ALTER TABLE livros DROP INDEX indice_por_lancamento;

Normalização é o processo de modelar o banco de dados projetando a forma como as
informações serão armazenadas a fim de eliminar, ou pelo menos diminuir, a redundância no
banco. Tal procedimento é feito a partir da identificação de uma anomalia em uma relação,
decompodo-as em relações melhor estruturadas.

Um banco de dados dentro dos padrões de normalização reduz o trabalho de manutenção e

ajuda a evitar o desperdício do espaço de armazenamento.

A primeira forma normal diz que todos os atríbutos devem ter apenas um único
correspondente, ou seja, não existem grupos repetidos ou campos que possuam mais de um
único valor.

Código | Nome | Endereço | Telefone

1001 | Diego Machado | Rua Tal 887 | 3362155412, 2363214141

Para resolver isso fazemos separado:

Código | Telefone
1001 | 3362155412
1001 | 2363214141

A segunda forma normal diz que devemos localizar os valores que dependem parcialmente da
chave primária, segue o exemplo:

cd_locacao | cd_filme | titulo_filme | devolucao | cd_cliente

1010 | 201 | The Matrix | 2011-10-12 | 743
1011 | 302 | O Grito | 2011-12-10 | 549
1012 | 201 | The Matrix | 2011-12-30 | 362

Podemos dizer que se não tivermos o código de locação podemos identificar o titulo do filme
pelo código do filme? SIM, então é uma dependência PARCIAL.

Podemos dizer que se não tivermos o código do filme, mas termos o código da locação
podemos identificar o titulo do filme? SIM, então também é uma dependência PARCIAL.

Podemos dizer que conseguimos identificar a data da devolução apenas com o código do
filme? NÃO! Conseguimos identificar a data de devolução pelo código da locação? SIM, ou
seja, temos aqui uma dependência TOTAL.

Conseguimos identificar o cliente pelo código do filme? NÃO! Conseguimos identificar o cliente
pelo código da locação? SIM, ou seja, uma outra dependência TOTAL.

Aplicando a segunda forma normal temos:

Cd_filme | titulo_filme
201 | The Matrix
302 | O Grito
A terceira forma normal diz que se encontrarmos um atributo não chave dependente de outro
atributo da mesma natureza, ou seja, também não chave devemos jogá-los em outra tabela,
isso se toda a tabela já se encontrar na primeira e segunda forma normal.

Placa | modelo | qnt_km_rodado | cod_fabr | nome_fabr

Podemos dizer que nome da fábrica é totalmente dependente do código da fábrica que não é
uma chave-primária (PLACA NESSA TABELA) então:

Tabela fabricantes:
Cod_fabr | nome_fabr

ENTIDADE
ATRIBUTOS
RELACIONAMENTOS
Modelos de dados, esquemas e instâncias.

MODELOS DE ALTO NÍVEL: oferece informações mais próxima do mundo real, focando nos
usuários finais.

Apresenta um modelo de entidades e relacionamentos.

ENTIDADES possuem ATRIBUTOS e se RELACIONAM com outras ENTIDADES.

MODELOS REPRESENTATIVOS: oferece conhecimento de modelos de baixo nível de uma forma

mais representativa para os usuários finais.

Apresenta um modelo RELACIONAL = Linguagem SQL.

MODELOS DE BAIXO NÍVEL: focados para especialista de banco de dados, chamado de DBA.

Descreve como o dado é armazenado e índices.

OU SEJA, primeiro se possui informações de como os dados se comportam no mundo real,

depois representamos essas entidades, seus atributos e relacionamentos atráves de uma
inferface onde é possível se ver todos esses eventos acontecendo por meio do uso de uma
linguagem usada pelos DBA que é a SQL e por fim no último nível de “organização” de fases
desses dados temos informações a respeito de onde esses dados específicos estão
armazenados, em que formatos e ainda se possuem auxílio de índices para melhorarem suas
performances em consultas querys SQL.

Esquema do Banco de Dados.

O esquema do BD refere-se a sua descrição e que normalmente não muda e sim somente o
seu conteúdo e isso sim com uma certa frequência.

ESTADO VAZIO – PROJEÇÃO DO BANCO DE DADOS

ESTADO INICIAL – INICIO DA POPULAÇÃO DO BANCO DE DADOS
ESTADO ATUAL 1 – DADOS EM UM PERÍODO DO TEMPO
ESTADO ATUAL 2 – DADOS EM OUTRO PERÍDO DO TEMPO
ESTADO ATUAL 3 – DADOS ATUAIS DENTRO DE UM PERÍODO DO TEMPO
SE CADA ESTADO ATUAL TIVER DADOS QUE SUPORTEM A ESTRUTURA DO BD ENTÃO TEMOS
UM ESTADO VÁLIDO QUE CONSIGA REFLETIR O QUE ACONTECE POR FORA NO MUNDO REAL.
Processos de Implementação.

LEVANTAMENTO E ANÁLISE DOS REQUISITOS: projetistas de banco de dados entrevistam os

usuários para entender as necessidades e então documentar os requisitos detalhadamente
pedidos.

- REQUISITOS FUNCIONAIS: consiste nas operações e/ou transações definidas pelos

usuários que serão implementadas e aplicadas ao BD. MUITO MAIS FOCADA no design
do software que vai estar sendo desenvolvimento para fazer a interação do usuário
com algum sistema que vai estar por trás dos palnos alimentando o DB.

PROJETO CONCEITUAL: um esquema de descreve de forma clara baseado nos requisitos dos
usuários os tipos de entidades, atributos e relacionamentos e restrições que vão ser
implementadas ao BD. PARTE DE APROVAÇÃO por parte dos clientes, projetistas ou usários.

PROJETO LÓGICO (MAPEAMENTO DO MODELO DE DADOS): hora de escolher um SGBD da

empresa ou de meu uso próprio.

PROJETO FÍSICO: onde estruturas de armazenamentos internos, como atualização de arquivos

e então seus dados, índices, caminhos de acessos e etc vão ser especificados.

MODELO ER – ENTIDADE E RELACIONAMENTO.

ENTIDADE: representa uma coisa ou um objeto do mundo real com uma existência
independente.

ATRIBUTO: são características de uma entidade e podem ser físicas como endereço e idade ou
ainda conceituais como o nome e cargo.