resources-sql.sql

USE SAKILA;
-- m d 

# 1_
CREATE OR REPLACE VIEW BUSCAR_FILME AS
SELECT
    FILM_ID,
    TITLE
FROM
    CUSTOMER
        INNER JOIN ADDRESS USING(ADDRESS_ID)
        INNER JOIN CITY USING(CITY_ID)
        INNER JOIN COUNTRY USING(COUNTRY_ID)
        INNER JOIN RENTAL USING(CUSTOMER_ID)
        INNER JOIN INVENTORY USING(INVENTORY_ID)
        INNER JOIN FILM USING(FILM_ID)
WHERE
    ACTIVE = 0
    AND COUNTRY LIKE "A%";
    
SELECT * FROM BUSCAR_FILME;
    

# 2_
CREATE OR REPLACE VIEW FILMES_FORA_DO_ESTOQUE AS
SELECT
    FILM_ID,
    TITLE
FROM
    FILM
        INNER JOIN FILM_ACTOR USING(FILM_ID)
        INNER JOIN ACTOR USING(ACTOR_ID)
        INNER JOIN FILM_CATEGORY USING(FILM_ID)
        INNER JOIN CATEGORY USING(CATEGORY_ID)
        LEFT JOIN INVENTORY USING(FILM_ID)
GROUP BY
    FILM_ID;
        
SELECT * FROM FILMES_FORA_DO_ESTOQUE;
        

# 3_
CREATE OR REPLACE VIEW FILMES AS
SELECT
    FILM.TITLE AS TITULO,
    CATEGORY.NAME AS CATEGORIA
FROM
    FILM
        INNER JOIN FILM_CATEGORY USING(FILM_ID)
        INNER JOIN CATEGORY USING(CATEGORY_ID)
        INNER JOIN INVENTORY USING(FILM_ID)
        INNER JOIN RENTAL USING(INVENTORY_ID)
WHERE
    MONTH(RENTAL_DATE) = 5
    AND YEAR(RENTAL_DATE) = 2005
    AND CATEGORY.NAME IN ('Action','Drama','Documentary')
UNION
SELECT
    FILM.TITLE AS TITULO,
    CATEGORY.NAME AS CATEGORIA
FROM
    FILM
        INNER JOIN FILM_CATEGORY USING(FILM_ID)
        INNER JOIN CATEGORY USING(CATEGORY_ID)
WHERE
    RENTAL_DURATION < 5
    AND LENGTH > 100
    AND CATEGORY.NAME IN ('Animation','Comedy','Horror');
    
SELECT * FROM FILMES;



# 4_ 
CREATE TABLE IF NOT EXISTS PAGAMENTOS_REALIZADOS
SELECT
    COUNT(PAYMENT_ID) AS TOTAL_PAGAMENTOS,
    STORE_ID AS LOJA
FROM
    PAYMENT
        INNER JOIN STAFF USING(STAFF_ID)
        INNER JOIN STORE USING(STORE_ID)
GROUP BY
    LOJA;
    
SELECT * FROM PAGAMENTOS_REALIZADOS;



# 5_
CREATE TABLE IF NOT EXISTS CALCULO_LOJA
SELECT
    ROUND(AVG(AMOUNT),2) AS MEDIA,
    SUM(AMOUNT) AS TOTAL,
    COUNT(PAYMENT_ID) AS QTDE_PAGAMENTO,
    MAX(AMOUNT) AS VALOR_MAX,
    MIN(AMOUNT) AS VALOR_MIN
FROM
    PAYMENT
        INNER JOIN STAFF USING(STAFF_ID)
        INNER JOIN STORE USING(STORE_ID);

SELECT * FROM CALCULO_LOJA;




# 6_
CREATE TABLE IF NOT EXISTS TOTAL_VALORES_PAGOS
SELECT
    COUNT(RENTAL_ID) AS VALORES_PAGOS
FROM
    RENTAL
        INNER JOIN CUSTOMER USING(CUSTOMER_ID)
WHERE
    MONTH(RENTAL_DATE) IN (5,6,7,8,9)
    AND YEAR(RENTAL_DATE) = 2005
    AND ACTIVE = 0;
    
SELECT * FROM TOTAL_VALORES_PAGOS;



# 7_
CREATE TABLE IF NOT EXISTS Filme_Ator_Categoria
SELECT
    FILM_ID AS FILME_ID,
    TITLE AS TITULO,
    CONCAT(FIRST_NAME,' ',LAST_NAME) AS NOME_COMPLETO,
    CATEGORY.NAME AS CATEGORIA,
    CATEGORY_ID AS CATEGORIA_ID
FROM
    FILM
        INNER JOIN FILM_ACTOR USING(FILM_ID)
        INNER JOIN ACTOR USING(ACTOR_ID)
        INNER JOIN FILM_CATEGORY USING(FILM_ID)
        INNER JOIN CATEGORY USING(CATEGORY_ID)
ORDER BY
    FILME_ID;

SELECT * FROM Filme_Ator_Categoria;



# 8_
CREATE OR REPLACE VIEW Estoque_Aluguel AS
SELECT
    inventory_id,
    rental_id,
    customer_id,
    CATEGORIA,
    FILME_ID
FROM
    Filme_Ator_Categoria 
        INNER JOIN INVENTORY ON FILME_ID = FILM_ID
        INNER JOIN RENTAL USING(INVENTORY_ID)
ORDER BY
    INVENTORY_ID;

SELECT * FROM Estoque_Aluguel;



# 9_
CREATE OR REPLACE VIEW Pagamento_Categoria AS
SELECT
    SUM(AMOUNT) AS TOTAL,
    CATEGORIA
FROM
    Estoque_Aluguel
        INNER JOIN PAYMENT USING(CUSTOMER_ID)
GROUP BY
    CATEGORIA;
    
SELECT * FROM Pagamento_Categoria LIMIT 100;




# 10_
CREATE TABLE IF NOT EXISTS CLIENTES_ATIVOS
Select 
   CONCAT(First_name,' ', Last_name) as cliente,
   City.City as cidade, 
   Country.Country as pais
From 
  Customer
      Inner Join Address using (Address_id)
      Inner Join City using (City_id)
      Inner Join Country using (Country_id)
Where
   Active = 1;


CREATE OR REPLACE VIEW Clientes_Categoria AS
SELECT
    COUNT(cliente),
    CATEGORIA
FROM
    Filme_Ator_Categoria
        INNER JOIN INVENTORY ON FILME_ID = FILM_ID
        INNER JOIN RENTAL USING(INVENTORY_ID)
        INNER JOIN CUSTOMER USING(CUSTOMER_ID)
        INNER JOIN ADDRESS USING(ADDRESS_ID)
        INNER JOIN CITY USING(CITY_ID)
        INNER JOIN COUNTRY USING(COUNTRY_ID)
        INNER JOIN CLIENTES_ATIVOS ON cliente = CONCAT(First_name,' ', Last_name)
WHERE
    City.City = cidade
    AND Country.Country = pais
GROUP BY
    CATEGORIA;
    
SELECT * FROM Clientes_Categoria;




# 11_
USE CLASSICMODELS;

DELIMITER %
CREATE PROCEDURE MOSTRAR_CLIENTES()
BEGIN
    SELECT * FROM CUSTOMERS;
END%
DELIMITER ;

CALL MOSTRAR_CLIENTES();



# 12_
DELIMITER %
DROP PROCEDURE IF EXISTS ESCRITORIO_FATURAMENTO%
CREATE PROCEDURE ESCRITORIO_FATURAMENTO(IN PARAM_ESCRITORIO VARCHAR(50),IN PARAM_ANO INT)
BEGIN
    IF (PARAM_ANO > 0) THEN
        SELECT
            OFFICECODE,
            QUANTITYORDERED,
            PRODUCTNAME
        FROM
            OFFICES
                INNER JOIN EMPLOYEES USING(OFFICECODE)
                INNER JOIN CUSTOMERS ON SALESREPEMPLOYEENUMBER = EMPLOYEENUMBER
                INNER JOIN ORDERS USING(CUSTOMERNUMBER)
                INNER JOIN ORDERDETAILS USING(ORDERNUMBER)
                INNER JOIN PRODUCTS USING(PRODUCTCODE)
        WHERE
            OFFICES.CITY = PARAM_ESCRITORIO
            AND YEAR(ORDERDATE) = PARAM_ANO;
    ELSE
        SELECT 'ERRO AO PASSAR PARAMETRO' AS RESULTADO;
    END IF;
END%
DELIMITER ;

SELECT CITY FROM OFFICES;

CALL ESCRITORIO_FATURAMENTO('Boston',2003);



# 13_
DELIMITER %
DROP PROCEDURE IF EXISTS LISTA_CLIENTE%
CREATE PROCEDURE LISTA_CLIENTE()
BEGIN
    SELECT
        CUSTOMERNUMBER,
        CUSTOMERNAME,
        CITY,
        COUNTRY
    FROM
        CUSTOMERS
            INNER JOIN EMPLOYEES ON SALESREPEMPLOYEENUMBER = EMPLOYEENUMBER
    ORDER BY CUSTOMERNUMBER;
END%
DELIMITER ;

CALL LISTA_CLIENTE();




# 14_
DELIMITER %
DROP PROCEDURE IF EXISTS PRODUTOS_VENDIDOS%
CREATE PROCEDURE PRODUTOS_VENDIDOS(IN PARAM_ANO INT)
BEGIN
    IF (PARAM_ANO > 0) THEN
        SELECT
            SUM(QUANTITYORDERED) AS TOTAL_PEDIDOS
        FROM
            ORDERDETAILS
                INNER JOIN ORDERS USING(ORDERNUMBER)
        WHERE
            YEAR(ORDERDATE) = PARAM_ANO;
    ELSE
        SELECT 'ERRO AO PASSAR PARAMETRO' AS RESULTADO;
    END IF;
END%
DELIMITER ;

CALL PRODUTOS_VENDIDOS(2005);




# 15_
DELIMITER %
DROP PROCEDURE IF EXISTS INFO_PRODUTOS%
CREATE PROCEDURE INFO_PRODUTOS(IN PARAM_ANO INT,OUT PARAM_RESULTADO VARCHAR(50))
BEGIN
    DECLARE VAR_MAIOR_TOTAL_VENDIDO VARCHAR(50);
    DECLARE VAR_MAIOR_TOTAL_PEDIDO VARCHAR(50);
    DECLARE A VARCHAR(100);
    
    IF (PARAM_ANO > 0) THEN
        SELECT
            PRODUCTCODE AS CODIGO_PRODUTO,
            PRODUCTNAME AS NOME_PRODUTO,
            SUM(QUANTITYORDERED) AS TOTAL_PEDIDOS,
            SUM(QUANTITYORDERED*PRICEEACH) AS TOTAL_VENDIDO
        FROM
            ORDERDETAILS
                INNER JOIN PRODUCTS USING(PRODUCTCODE)
                INNER JOIN ORDERS USING(ORDERNUMBER)
        WHERE
            YEAR(ORDERDATE) = PARAM_ANO
        GROUP BY
            CODIGO_PRODUTO, NOME_PRODUTO
        ORDER BY
            TOTAL_VENDIDO DESC
        LIMIT 10;
        
        SELECT
            PRODUCTNAME,
            SUM(QUANTITYORDERED) AS TOTAL_PEDIDO
            INTO VAR_MAIOR_TOTAL_PEDIDO, @NULO
        FROM
            ORDERDETAILS
                INNER JOIN ORDERS USING(ORDERNUMBER)
                INNER JOIN PRODUCTS USING(PRODUCTCODE)
        WHERE
            YEAR(ORDERDATE) = PARAM_ANO
        GROUP BY
            PRODUCTNAME
        ORDER BY
            TOTAL_PEDIDO DESC
        LIMIT 1;
        
        SELECT
            PRODUCTNAME,
            SUM(QUANTITYORDERED*PRICEEACH) AS TOTAL_VENDIDO
            INTO VAR_MAIOR_TOTAL_VENDIDO, @NULO
        FROM
            ORDERDETAILS
                INNER JOIN ORDERS USING(ORDERNUMBER)
                INNER JOIN PRODUCTS USING(PRODUCTCODE)
        WHERE
            YEAR(ORDERDATE) = PARAM_ANO
        GROUP BY
            PRODUCTNAME
        ORDER BY
            TOTAL_VENDIDO DESC
        LIMIT 1;
            
        IF (VAR_MAIOR_TOTAL_PEDIDO = VAR_MAIOR_TOTAL_VENDIDO) THEN
            SET PARAM_RESULTADO = 'Produto Acima das Expectativa';
        ELSE
            SET PARAM_RESULTADO = 'Produtos diferentes';
        END IF;
    ELSE
        SELECT 'ERRO AO PASSAR PARAMETRO' AS RESULTADO;
    END IF;
END%
DELIMITER ;

CALL INFO_PRODUTOS(2003,@RESULTADO);
SELECT @RESULTADO;




# 16_
CREATE TABLE IF NOT EXISTS Vendedor_Avaliacao(
    Vendedor varchar(100), 
    Avaliacao varchar(100)
) ENGINE=INNODB;

CREATE OR REPLACE VIEW VENDEDOR_CLIENTE AS
SELECT IFNULL(COUNT(CUSTOMERNUMBER),0) QTDECLIENTE,
    CONCAT(LASTNAME, ' ', FIRSTNAME) VENDEDOR
FROM
     EMPLOYEES 
           INNER JOIN OFFICES USING (officeCode)
           LEFT JOIN CUSTOMERS ON (salesRepEmployeeNumber = employeeNumber)
WHERE JOBTITLE = 'SALES REP'
GROUP BY VENDEDOR ORDER BY QTDECLIENTE;

DELIMITER %
DROP PROCEDURE IF EXISTS VERIFICAR_VALORES%
CREATE PROCEDURE VERIFICAR_VALORES()
BEGIN
	DECLARE VAR_FINALIZADO BOOL DEFAULT FALSE;
    DECLARE VAR_RESULTADO VARCHAR(100);
    DECLARE VAR_VENDEDOR VARCHAR(100);
    
    DECLARE CURSOR_VENDEDOR CURSOR FOR
    SELECT
		VENDEDOR,
		CASE
			WHEN QTDECLIENTE > 8 THEN 'Você executou um excelente trabalho'
			WHEN QTDECLIENTE >= 6 THEN 'Bom trabalho, mas pode melhorar'
			WHEN QTDECLIENTE > 0 THEN 'Acreditamos no seu potencial, precisa de apoio?'
			ELSE 'Passar no RH'
		END
	FROM 
		VENDEDOR_CLIENTE;
        
	DECLARE CONTINUE HANDLER
		FOR NOT FOUND SET VAR_FINALIZADO = TRUE;
        
	OPEN CURSOR_VENDEDOR;
    
	LISTA: LOOP
		FETCH CURSOR_VENDEDOR INTO VAR_VENDEDOR, VAR_RESULTADO;
        
        IF (VAR_FINALIZADO = TRUE) THEN
			LEAVE LISTA;
		END IF;
        
		INSERT INTO VENDEDOR_AVALIACAO(Vendedor,Avaliacao) VALUES
        (VAR_VENDEDOR, VAR_RESULTADO);
	END LOOP;
    
    CLOSE CURSOR_VENDEDOR;
END%
DELIMITER ;

CALL VERIFICAR_VALORES();

SELECT * FROM VENDEDOR_AVALIACAO;




# 17_
CREATE TABLE IF NOT EXISTS DadosAluno (
	MatriculaAluno INT PRIMARY KEY,
    Nota_PI INT NOT NULL, 
    Nota_PR INT NOT NULL, 
    Nota_PF INT NOT NULL, 
    Total_Faltas INT, 
    Faltas_Possiveis INT
)ENGINE=INNODB;

INSERT INTO DadosAluno (MatriculaAluno, Nota_PI, Nota_PR, Nota_PF, Total_Faltas, Faltas_Possiveis) VALUES
(101, 20, 25, 30, 30, 200),
(102, 15, 20, 10, 50, 200),
(103, 25, 30, 35, 10, 200),
(104, 10, 10, 20, 60, 200),
(105, 30, 30, 30, 5, 200),
(106, 28, 26, 30, 12, 200),
(107, 10, 15, 20, 80, 200),
(108, 22, 18, 25, 25, 200),
(109, 18, 17, 19, 90, 200),
(110, 27, 28, 30, 20, 200),
(111, 12, 13, 15, 40, 200),
(112, 30, 30, 30, 85, 200),
(113, 29, 29, 28, 18, 200),
(114, 23, 20, 22, 50, 200),
(115, 14, 15, 16, 30, 200);

DELIMITER %
DROP PROCEDURE IF EXISTS VERIFICAR_NOTA%
CREATE PROCEDURE VERIFICAR_NOTA(IN PARAM_NUM_MATRICULA INT)
BEGIN
	DECLARE VAR_VERIFICAR INT DEFAULT 0;
    
	SELECT COUNT(MATRICULAALUNO) INTO VAR_VERIFICAR FROM DADOSALUNO WHERE MATRICULAALUNO = PARAM_NUM_MATRICULA;
    
    IF (VAR_VERIFICAR > 0) THEN
		SELECT
			MATRICULAALUNO AS MATRICULA,
            SUM(NOTA_PI + NOTA_PR + NOTA_PF) AS NOTA_TOTAL,
            CONCAT(ROUND(SUM((TOTAL_FALTAS/Faltas_Possiveis)*100),2),'%') AS AULAS_FALTADAS,
            CASE
				WHEN (SUM(NOTA_PI + NOTA_PR + NOTA_PF) >= 60 AND SUM((TOTAL_FALTAS/Faltas_Possiveis)*100) <= 25) OR (SUM(NOTA_PI + NOTA_PR + NOTA_PF) >= 90 AND SUM((TOTAL_FALTAS/Faltas_Possiveis)*100) <= 40) THEN 'APROVADO'
                WHEN SUM(NOTA_PI + NOTA_PR + NOTA_PF) >= 45 THEN 'EM RECUPERAÇÃO'
                ELSE 'REPROVADO'
			END AS RESULTADO
		FROM
			DadosAluno
		WHERE
			MATRICULAALUNO = PARAM_NUM_MATRICULA;
    ELSE
		SELECT 'ERRO AO PASSAR PARAMETRO' AS RESULTADO;
	END IF;
END%
DELIMITER ;

CALL VERIFICAR_NOTA(101);





# 18_
CREATE TABLE IF NOT EXISTS SACOLA(
	NUM_BOLA INT NOT NULL PRIMARY KEY,
	COR_BOLA VARCHAR(50) NOT NULL,
    QTDE_BOLA INT NOT NULL
)ENGINE=INNODB;

DELIMITER %
DROP PROCEDURE IF EXISTS ADICIONAR_BOLA%
DROP PROCEDURE IF EXISTS ALTERAR_BOLA%
DROP PROCEDURE IF EXISTS EXCLUIR_BOLA%
CREATE PROCEDURE ADICIONAR_BOLA(IN PARAM_COR_BOLA VARCHAR(50),IN PARAM_NUM_BOLA INT,IN PARAM_QTDE FLOAT)
BEGIN
	DECLARE VAR_VERIFICAR_BOLA INT DEFAULT 0;
    DECLARE VAR_VERIFICAR_COR INT DEFAULT 0;
    DECLARE VAR_CAPACIDADE INT DEFAULT 200;
    DECLARE VAR_QTDE_ATUAL INT DEFAULT 0;
    DECLARE VAR_QTDE_FINAL INT DEFAULT 0;
    DECLARE VAR_QTDE INT DEFAULT 0;
    
    SELECT ROUND(PARAM_QTDE) INTO VAR_QTDE;
    
	IF (PARAM_QTDE >= 1 AND VAR_QTDE > 0) THEN
		SELECT COUNT(NUM_BOLA) INTO VAR_VERIFICAR_BOLA FROM SACOLA WHERE NUM_BOLA = PARAM_NUM_BOLA;
		IF (VAR_VERIFICAR_BOLA = 0 AND PARAM_NUM_BOLA > 0) THEN
			SELECT COUNT(COR_BOLA) INTO VAR_VERIFICAR_COR FROM SACOLA WHERE COR_BOLA = PARAM_COR_BOLA;
			IF (VAR_VERIFICAR_COR = 0) THEN
				SELECT IFNULL(SUM(QTDE_BOLA),0) INTO VAR_QTDE_ATUAL FROM SACOLA;
                
                SET VAR_QTDE_FINAL = VAR_QTDE_ATUAL + VAR_QTDE;
                
                IF (VAR_QTDE_FINAL <= VAR_CAPACIDADE) THEN
					INSERT INTO SACOLA(COR_BOLA,NUM_BOLA,QTDE_BOLA) VALUES
					(PARAM_COR_BOLA,PARAM_NUM_BOLA,VAR_QTDE);
                    SELECT 'BOLA ADICIONADA NA SACOLA COM SUCESSO' AS RESULTADO;
				ELSE
					SELECT '** VOCÊ ULTRAPASSOU A CAPACIDADE DA SACOLA. POR FAVOR, INSIRA OUTRO VALOR. ** ' AS RESULTADO;
                END IF;
			ELSE
				SELECT 'COR DA BOLA JA POSSUI QUANTIDADE MAXIMA' AS RESULTADO;
			END IF;
		ELSE
			CALL ALTERAR_BOLA(PARAM_COR_BOLA,PARAM_NUM_BOLA,PARAM_QTDE);
		END IF;
	ELSE
		SELECT '** O VALOR INSERIDO É INVALIDO. POR FAVOR, TENTE NOVAMENTE! **' AS RESULTADO;
	END IF;
END%
CREATE PROCEDURE ALTERAR_BOLA(IN PARAM_COR_BOLA VARCHAR(50),IN PARAM_NUM_BOLA INT,IN PARAM_QTDE FLOAT)
BEGIN
	DECLARE VAR_VERIFICAR_BOLA INT DEFAULT 0;
    DECLARE VAR_VERIFICAR_COR INT DEFAULT 0;
    DECLARE VAR_CAPACIDADE INT DEFAULT 200;
    DECLARE VAR_QTDE_ATUAL INT DEFAULT 0;
    DECLARE VAR_QTDE_FINAL INT DEFAULT 0;
    DECLARE VAR_QTDE INT DEFAULT 0;
    
    SELECT ROUND(PARAM_QTDE) INTO VAR_QTDE;
    
	IF (PARAM_QTDE >= 1 AND PARAM_QTDE < 0) THEN
		SELECT IFNULL(NUM_BOLA,0) INTO VAR_VERIFICAR_BOLA FROM SACOLA WHERE NUM_BOLA = PARAM_NUM_BOLA;
		IF (VAR_VERIFICAR_BOLA > 1) THEN
			SELECT COUNT(COR_BOLA) INTO VAR_VERIFICAR_COR FROM SACOLA WHERE COR_BOLA = PARAM_COR_BOLA;
			IF (VAR_VERIFICAR_COR = 0) THEN
				SELECT IFNULL(SUM(QTDE_BOLA),0) INTO VAR_QTDE_ATUAL FROM SACOLA;
                
                SET VAR_QTDE_FINAL = VAR_QTDE_ATUAL + VAR_QTDE;
                
                IF (VAR_QTDE_FINAL <= VAR_CAPACIDADE AND VAR_QTDE_FINAL > 0) THEN
					UPDATE SACOLA
                    SET COR_BOLA = PARAM_COR_BOLA AND QTDE_BOLA = VAR_QTDE
                    WHERE NUM_BOLA = VAR_VERIFICAR_BOLA;
                    SELECT 'BOLA ALTERADA COM SUCESSO' AS RESULTADO;
				ELSEIF (VAR_QTDE_FINAL <= 0) THEN
					CALL EXCLUIR_BOLA(VAR_VERIFICAR_BOLA);
				ELSE
					SELECT '** VOCÊ ULTRAPASSOU A CAPACIDADE DA SACOLA. POR FAVOR, INSIRA OUTRO VALOR. ** ' AS RESULTADO;
                END IF;
			ELSE
				SELECT 'COR DA BOLA JA POSSUI QUANTIDADE MAXIMA' AS RESULTADO;
			END IF;
		ELSE
			CALL ADICIONAR_BOLA(PARAM_COR_BOLA,PARAM_NUM_BOLA,PARAM_QTDE);
		END IF;
	ELSE
		SELECT '** O VALOR INSERIDO É INVALIDO. POR FAVOR, TENTE NOVAMENTE! **' AS RESULTADO;
	END IF;
END%
CREATE PROCEDURE EXCLUIR_BOLA(IN PARAM_NUM_BOLA INT)
BEGIN
	DECLARE VAR_VERIFICAR_BOLA INT DEFAULT 0;
    
	SELECT IFNULL(NUM_BOLA,0) INTO VAR_VERIFICAR_BOLA FROM SACOLA WHERE NUM_BOLA = PARAM_NUM_BOLA;
	IF (VAR_VERIFICAR_BOLA > 1) THEN
		DELETE FROM SACOLA 
        WHERE NUM_BOLA = VAR_VERIFICAR_BOLA;
	ELSE
		SELECT 'BOLA NÃO EXISTE NA SACOLA' AS RESULTADO;
	END IF;
END%
DELIMITER ;

CALL ADICIONAR_BOLA('PRETA',1,3);
CALL ALTERAR_BOLA('VERMELHA',1,5);
CALL EXCLUIR_BOLA(1);




# 19_
DELIMITER %
DROP PROCEDURE IF EXISTS CRIAR_TRIANGULO%
CREATE PROCEDURE CRIAR_TRIANGULO(IN A INT,IN B INT,IN C INT)
BEGIN
	IF (A > 0 AND B > 0 AND C > 0) THEN
		IF ((A + B) > C AND (A + C) > B AND (B + C) > A) THEN
			SELECT CASE 
				WHEN A = B AND B = C THEN 'TRIANGULO EQUILATERO'
				WHEN A = B OR B = C OR C = A THEN 'TRIANGULO ISOCELES'
				ELSE 'TRIANGULO ESCALENO'
			END AS RESULTADO;
		ELSE
			SELECT 'NÃO É UM TRIANGULO' AS RESULTADO;
		END IF;
    ELSE
		SELECT 'ERRO AO PASSAR PARAMETRO' AS RESULTADO;
	END IF;
END%
DELIMITER ;

CALL CRIAR_TRIANGULO(3,4,5);




# 20_
CREATE TABLE Taxa_Crescimento_De_Venda (
    Id_Vendedor INT,
    Nome_Vendedor VARCHAR(100),
    Ano INT,
    Valor_Janeiro_base FLOAT,
    Taxa_Fevereiro VARCHAR(5),
    Taxa_Marco VARCHAR(5),
    Taxa_Abril VARCHAR(5),
    Taxa_Maio VARCHAR(5),
    Taxa_Junho VARCHAR(5),
    CONSTRAINT PK_TAXA PRIMARY KEY (Id_Vendedor, Ano, Valor_Janeiro_base)
);
CREATE TABLE VENDAS (
    ID_VENDEDOR INT,
    NOME_VENDEDOR VARCHAR(100),
    DATA_VENDA DATE,
    VALOR_VENDA FLOAT
);

INSERT INTO VENDAS (ID_VENDEDOR, NOME_VENDEDOR, DATA_VENDA, VALOR_VENDA) VALUES
(1, 'Carlos Silva', '2025-01-15', 10000.00),
(1, 'Carlos Silva', '2025-02-15', 11000.00),
(1, 'Carlos Silva', '2025-03-15', 12100.00),
(1, 'Carlos Silva', '2025-04-15', 13310.00),
(1, 'Carlos Silva', '2025-05-15', 14641.00),
(1, 'Carlos Silva', '2025-06-15', 16105.10),

(2, 'Ana Souza', '2025-01-10', 8000.00),
(2, 'Ana Souza', '2025-02-10', 8400.00),
(2, 'Ana Souza', '2025-03-10', 8820.00),
(2, 'Ana Souza', '2025-04-10', 9261.00),
(2, 'Ana Souza', '2025-05-10', 9724.05),
(2, 'Ana Souza', '2025-06-10', 10210.25),

(3, 'Bruno Lima', '2025-01-05', 12000.00),
(3, 'Bruno Lima', '2025-02-05', 12600.00),
(3, 'Bruno Lima', '2025-03-05', 13230.00),
(3, 'Bruno Lima', '2025-04-05', 13891.50),
(3, 'Bruno Lima', '2025-05-05', 14586.08),
(3, 'Bruno Lima', '2025-06-05', 15315.39),

(4, 'Fernanda Alves', '2025-01-20', 9500.00),
(4, 'Fernanda Alves', '2025-02-20', 9975.00),
(4, 'Fernanda Alves', '2025-03-20', 10473.75),
(4, 'Fernanda Alves', '2025-04-20', 11000.44),
(4, 'Fernanda Alves', '2025-05-20', 11550.46),
(4, 'Fernanda Alves', '2025-06-20', 12127.98),

(5, 'João Pedro', '2025-01-25', 7000.00),
(5, 'João Pedro', '2025-02-25', 7350.00),
(5, 'João Pedro', '2025-03-25', 7717.50),
(5, 'João Pedro', '2025-04-25', 8103.37),
(5, 'João Pedro', '2025-05-25', 8508.54),
(5, 'João Pedro', '2025-06-25', 8934.00);

INSERT INTO Taxa_Crescimento_De_Venda (
    Id_Vendedor, Nome_Vendedor, Ano, Valor_Janeiro_base,
    Taxa_Fevereiro, Taxa_Marco, Taxa_Abril, Taxa_Maio, Taxa_Junho
) VALUES
(1, 'Carlos Silva', 2025, 10000.00, '10%', '10%', '10%', '10%', '10%'),
(4, 'Fernanda Alves', 2025, 9500.00, '5%', '5%', '5%', '5%', '5%');

CREATE VIEW VENDAS_MENSAIS AS
SELECT 
    VENDAS.Id_Vendedor AS ID_VENDEDOR,
    VENDAS.Nome_Vendedor AS NOME_VENDEDOR,
    YEAR(VENDAS.Data_Venda) AS ANO,
    MONTH(VENDAS.Data_Venda) AS Mes_Venda,
    SUM(VENDAS.Valor_Venda) AS Total_Venda
FROM 
    VENDAS
WHERE 
    MONTH(VENDAS.Data_Venda) BETWEEN 1 AND 6 -- Apenas primeiros 6 meses
GROUP BY 
    VENDAS.Id_Vendedor, VENDAS.Nome_Vendedor, YEAR(VENDAS.Data_Venda), MONTH(VENDAS.Data_Venda);
    
DELIMITER %
DROP PROCEDURE IF EXISTS ALTERAR_VENDAS_MENSAIS%
CREATE PROCEDURE ALTERAR_VENDAS_MENSAIS()
BEGIN
    DECLARE VAR_FINALIZADO BOOL DEFAULT FALSE;
    DECLARE VAR_ID_VENDEDOR INT;
    DECLARE VAR_ANO INT;
    DECLARE VAR_VALOR_ANTERIOR FLOAT;
    DECLARE VAR_VALOR_ATUAL FLOAT;
    DECLARE VAR_TAXA FLOAT;
    DECLARE VAR_TAXA_FORMATADA VARCHAR(6);
    DECLARE VAR_MES INT DEFAULT 2;

    DECLARE CURSOR_VENDAS CURSOR FOR
        SELECT DISTINCT ID_VENDEDOR FROM VENDAS_MENSAIS;

    DECLARE CONTINUE HANDLER FOR NOT FOUND SET VAR_FINALIZADO = TRUE;

    OPEN CURSOR_VENDAS;

    LOOP_VENDEDOR: LOOP
        FETCH CURSOR_VENDAS INTO VAR_ID_VENDEDOR;

        IF VAR_FINALIZADO THEN
            LEAVE LOOP_VENDEDOR;
        END IF;

        INSERT INTO Taxa_Crescimento_De_Venda (ID_VENDEDOR, NOME_VENDEDOR, ANO, VALOR_JANEIRO_BASE)
        SELECT 
            VM.ID_VENDEDOR,
            VM.NOME_VENDEDOR,
            VM.ANO,
            SUM(VM.TOTAL_VENDA)
        FROM 
            VENDAS_MENSAIS VM
            LEFT JOIN Taxa_Crescimento_De_Venda TCDV ON VM.ID_VENDEDOR = TCDV.ID_VENDEDOR AND VM.ANO = TCDV.ANO
        WHERE 
            VM.MES_VENDA = 1
            AND TCDV.ID_VENDEDOR IS NULL
            AND VM.ID_VENDEDOR = VAR_ID_VENDEDOR
        GROUP BY 
            VM.ID_VENDEDOR, VM.NOME_VENDEDOR, VM.ANO;

        SELECT 
            VALOR_JANEIRO_BASE, ANO INTO VAR_VALOR_ANTERIOR, VAR_ANO
        FROM 
            Taxa_Crescimento_De_Venda
        WHERE 
            ID_VENDEDOR = VAR_ID_VENDEDOR;

        SET VAR_MES = 2;

        REPEAT
            SELECT 
                SUM(TOTAL_VENDA) INTO VAR_VALOR_ATUAL
            FROM 
                VENDAS_MENSAIS
            WHERE 
                ID_VENDEDOR = VAR_ID_VENDEDOR
                AND ANO = VAR_ANO
                AND MES_VENDA = VAR_MES;

            IF VAR_VALOR_ATUAL IS NOT NULL AND VAR_VALOR_ANTERIOR IS NOT NULL AND VAR_VALOR_ANTERIOR > 0 THEN
                SET VAR_TAXA = ((VAR_VALOR_ATUAL / VAR_VALOR_ANTERIOR) - 1) * 100;
                SET VAR_TAXA_FORMATADA = CASE 
                    WHEN VAR_TAXA >= 0 THEN CONCAT('+', CAST(ROUND(VAR_TAXA, 0) AS CHAR), '%')
                    ELSE CONCAT(CAST(ROUND(VAR_TAXA, 0) AS CHAR), '%')
                END;

                UPDATE Taxa_Crescimento_De_Venda
                SET Taxa_Fevereiro = CASE WHEN VAR_MES = 2 THEN VAR_TAXA_FORMATADA ELSE Taxa_Fevereiro END,
                    Taxa_Marco = CASE WHEN VAR_MES = 3 THEN VAR_TAXA_FORMATADA ELSE Taxa_Marco END,
                    Taxa_Abril = CASE WHEN VAR_MES = 4 THEN VAR_TAXA_FORMATADA ELSE Taxa_Abril END,
                    Taxa_Maio = CASE WHEN VAR_MES = 5 THEN VAR_TAXA_FORMATADA ELSE Taxa_Maio END,
                    Taxa_Junho = CASE WHEN VAR_MES = 6 THEN VAR_TAXA_FORMATADA ELSE Taxa_Junho END
                WHERE ID_VENDEDOR = VAR_ID_VENDEDOR AND ANO = VAR_ANO;

                SET VAR_VALOR_ANTERIOR = VAR_VALOR_ATUAL;
            END IF;

            SET VAR_MES = VAR_MES + 1;
        UNTIL VAR_MES > 6
        END REPEAT;
    END LOOP;

    CLOSE CURSOR_VENDAS;

    SELECT * FROM Taxa_Crescimento_De_Venda;
    SELECT * FROM VENDAS;
END%
DELIMITER ;

START TRANSACTION;
CALL ALTERAR_VENDAS_MENSAIS();
ROLLBACK;
COMMIT;





# 21_
USE WORLD;

SET SESSION group_concat_max_len = 10000;

DROP TABLE IF EXISTS CIDADE_PAIS;
CREATE TABLE IF NOT EXISTS CIDADE_PAIS
SELECT
	COUNTRY.NAME AS NOMEPAIS,
    CODE AS CODEPAIS,
    CONTINENT AS CONTINENTE,
    GROUP_CONCAT(CITY.NAME ORDER BY CITY.NAME SEPARATOR ', ') AS CIDADESEXISTENTE,
    SURFACEAREA AS TERRITORIO,
    COUNTRY.POPULATION AS POPULACAO,
    '' AS SITUACAODEMOGRAFICA,
    '' AS IDIOMASFALADOS
FROM
	COUNTRY
		LEFT JOIN CITY ON CODE = COUNTRYCODE
GROUP BY
	COUNTRY.NAME,CODE,CONTINENT,SURFACEAREA,COUNTRY.POPULATION;

DESCRIBE CIDADE_PAIS;
ALTER TABLE CIDADE_PAIS
MODIFY SITUACAODEMOGRAFICA VARCHAR(100);
ALTER TABLE CIDADE_PAIS
MODIFY IDIOMASFALADOS TEXT;

DROP TABLE IF EXISTS LOG_CIDADE_PAIS;
CREATE TABLE IF NOT EXISTS LOG_CIDADE_PAIS(
	ID INT PRIMARY KEY AUTO_INCREMENT,
    DESCRICAO VARCHAR(200),
    DATA TIMESTAMP
)ENGINE=INNODB;

CREATE OR REPLACE VIEW AGRUPAMENTO_IDIOMAS AS
SELECT
	NOMEPAIS,
    CODEPAIS,
    TERRITORIO,
    POPULACAO,
    GROUP_CONCAT(LANGUAGE ORDER BY LANGUAGE SEPARATOR ', ') AS LISTAIDIOMAS
FROM
	CIDADE_PAIS
		INNER JOIN COUNTRYLANGUAGE ON CODEPAIS = COUNTRYCODE
GROUP BY
	NOMEPAIS,CODEPAIS,TERRITORIO,POPULACAO;

SELECT * FROM AGRUPAMENTO_IDIOMAS;
    
DELIMITER %
DROP FUNCTION IF EXISTS CALCULAR_DENSIDADE%
CREATE FUNCTION CALCULAR_DENSIDADE(PARAM_TERRITORIO FLOAT, PARAM_POPULACAO INT) RETURNS VARCHAR(50) DETERMINISTIC
BEGIN
	DECLARE VAR_RETORNAR VARCHAR(50);
    DECLARE DENSIDADE DECIMAL(10,2);

    IF PARAM_TERRITORIO = 0 THEN
        RETURN 'Erro: Território zero';
    END IF;

    SET DENSIDADE = PARAM_POPULACAO / PARAM_TERRITORIO;

    IF DENSIDADE >= 90 THEN
        SET VAR_RETORNAR = 'Populoso';
    ELSEIF DENSIDADE >= 20 THEN
        SET VAR_RETORNAR = 'Povoado';
    ELSE
        SET VAR_RETORNAR = 'Incentiva imigração';
    END IF;

    RETURN VAR_RETORNAR;
END%
DROP TRIGGER IF EXISTS AFTER_UPDATE%
CREATE TRIGGER AFTER_UPDATE
AFTER UPDATE ON CIDADE_PAIS FOR EACH ROW
BEGIN
	DECLARE descricao TEXT DEFAULT '';
    DECLARE cidades_antigas TEXT;
    DECLARE cidades_novas TEXT;
    
    SELECT GROUP_CONCAT(Name ORDER BY Name SEPARATOR ', ')
    INTO cidades_antigas
    FROM City
    WHERE CountryCode = OLD.CODEPAIS;
    
    SELECT GROUP_CONCAT(Name ORDER BY Name SEPARATOR ', ')
    INTO cidades_novas
    FROM City
    WHERE CountryCode = NEW.CODEPAIS;
    
    IF NOT OLD.NOMEPAIS <=> NEW.NOMEPAIS THEN
        SET descricao = CONCAT(descricao, 'NomePais: "', OLD.NOMEPAIS, '" -> "', NEW.NOMEPAIS, '"; ');
    END IF;

    IF NOT OLD.CODEPAIS <=> NEW.CODEPAIS THEN
        SET descricao = CONCAT(descricao, 'CodePais: "', OLD.CODEPAIS, '" -> "', NEW.CODEPAIS, '"; ');
    END IF;

    IF NOT OLD.CONTINENTE <=> NEW.CONTINENTE THEN
        SET descricao = CONCAT(descricao, 'Continente: "', OLD.CONTINENTE, '" -> "', NEW.CONTINENTE, '"; ');
    END IF;

    IF NOT cidades_antigas <=> cidades_novas THEN
        SET descricao = CONCAT(descricao, 'CidadesExistente: "', IFNULL(cidades_antigas, ''), '" -> "', IFNULL(cidades_novas, ''), '"; ');
    END IF;

    IF NOT OLD.TERRITORIO <=> NEW.TERRITORIO THEN
        SET descricao = CONCAT(descricao, 'Territorio: "', OLD.TERRITORIO, '" -> "', NEW.TERRITORIO, '"; ');
    END IF;

    IF NOT OLD.POPULACAO <=> NEW.POPULACAO THEN
        SET descricao = CONCAT(descricao, 'Populacao: "', OLD.POPULACAO, '" -> "', NEW.POPULACAO, '"; ');
    END IF;
    
    IF descricao != '' THEN
        INSERT INTO MinhaTabela_Log(DATA, DESCRICAO)
        VALUES (CURRENT_TIMESTAMP(), descricao);
    END IF;
END%
DROP PROCEDURE IF EXISTS INSERIR_VALORES%
CREATE PROCEDURE INSERIR_VALORES()
BEGIN
	DECLARE VAR_FINALIZADO BOOL DEFAULT FALSE;
    DECLARE VAR_IDIOMASFALADOS TEXT;
    DECLARE VAR_SITUACAODEMOGRAFICA VARCHAR(100);
    DECLARE VAR_ID_PAIS VARCHAR(3);
    
    DECLARE CURSOR_PEGAR_PAISES CURSOR FOR
    SELECT CODEPAIS FROM AGRUPAMENTO_IDIOMAS;
    
    DECLARE CONTINUE HANDLER
		FOR NOT FOUND SET VAR_FINALIZADO = TRUE;
	
    OPEN CURSOR_PEGAR_PAISES;
    
    LISTA: LOOP
		FETCH CURSOR_PEGAR_PAISES INTO VAR_ID_PAIS;
        IF (VAR_FINALIZADO = TRUE) THEN
			LEAVE LISTA;
		END IF;
        
		SELECT
			LISTAIDIOMAS,
			CALCULAR_DENSIDADE(POPULACAO,TERRITORIO)
			INTO
			VAR_IDIOMASFALADOS,
			VAR_SITUACAODEMOGRAFICA
		FROM
			AGRUPAMENTO_IDIOMAS
		WHERE 
			CODEPAIS = VAR_ID_PAIS
		LIMIT 1;
			
		IF VAR_SITUACAODEMOGRAFICA IS NOT NULL AND VAR_IDIOMASFALADOS IS NOT NULL THEN
			UPDATE CIDADE_PAIS
			SET SITUACAODEMOGRAFICA = VAR_SITUACAODEMOGRAFICA, IDIOMASFALADOS = VAR_IDIOMASFALADOS
			WHERE CODEPAIS = VAR_ID_PAIS;
		END IF;
    END LOOP;
    
    CLOSE CURSOR_PEGAR_PAISES;
    
    SELECT * FROM CIDADE_PAIS;
END%
DELIMITER ;

START TRANSACTION;
CALL INSERIR_VALORES();
ROLLBACK;
COMMIT;




# 22_
USE CLASSICMODELS;

CREATE TABLE IF NOT EXISTS CLIENTE_TOTAL_PAGAMENTO
SELECT
	EMPLOYEENUMBER AS CODIGOEMPREGADO,
    COUNT(CUSTOMERNUMBER) AS QTDE_CLIENTE,
    SUM(AMOUNT) AS TOTALPAGAMENTO,
    CONCAT(FIRSTNAME,' ',LASTNAME) AS NOMEEMPREGADO,
    '' AS ESCRITORIO,
    '' AS SITUACAOESCRITORIO
FROM
	EMPLOYEES
		INNER JOIN CUSTOMERS ON SALESREPEMPLOYEENUMBER = EMPLOYEENUMBER
        INNER JOIN PAYMENTS USING(CUSTOMERNUMBER)
GROUP BY
	EMPLOYEENUMBER, NOMEEMPREGADO;

DESCRIBE CLIENTE_TOTAL_PAGAMENTO;
ALTER TABLE CLIENTE_TOTAL_PAGAMENTO
MODIFY ESCRITORIO VARCHAR(50);
ALTER TABLE CLIENTE_TOTAL_PAGAMENTO
MODIFY SITUACAOESCRITORIO VARCHAR(100);
    
DROP TABLE IF EXISTS LOG_CLIENTE_TOTAL_PAGO;
CREATE TABLE IF NOT EXISTS LOG_CLIENTE_TOTAL_PAGO(
	ID INT PRIMARY KEY AUTO_INCREMENT,
    DESCRICAO VARCHAR(200) NOT NULL,
    DATA TIMESTAMP
)ENGINE=INNODB;

CREATE OR REPLACE VIEW CLIENTE_ESCRITORIO_TOTAL AS
SELECT
	CODIGOEMPREGADO,
    QTDE_CLIENTE,
    TOTALPAGAMENTO,
    NOMEEMPREGADO,
    OFFICES.CITY AS CIDADEESCRITORIO
FROM
	CLIENTE_TOTAL_PAGAMENTO
		INNER JOIN EMPLOYEES ON EMPLOYEENUMBER = CODIGOEMPREGADO
        INNER JOIN OFFICES USING(OFFICECODE);
	
SELECT * FROM CLIENTE_ESCRITORIO_TOTAL;

DELIMITER %
DROP FUNCTION IF EXISTS CALCULAR_VALOR_PRECO%
CREATE FUNCTION CALCULAR_VALOR_PRECO(PARAM_CIDADEESCRITORIO VARCHAR(50), PARAM_TOTAL_PAGAMENTO DECIMAL(10,2)) RETURNS VARCHAR(100) DETERMINISTIC
BEGIN
	DECLARE VAR_RETORNAR VARCHAR(100);
    
    SELECT CASE
		WHEN PARAM_CIDADEESCRITORIO = 'Paris' AND PARAM_TOTAL_PAGAMENTO > 900000 THEN 'Escritório superou expectativas - Comemoração'
        WHEN PARAM_TOTAL_PAGAMENTO > 700000 THEN 'Excelente trabalho equipe'
        ELSE 'Bom trabalho, mas vamos melhorar'
	END INTO VAR_RETORNAR;
    
    RETURN VAR_RETORNAR;
END%
DROP TRIGGER IF EXISTS AFTER_UPDATE_CLIENTE%
CREATE TRIGGER AFTER_UPDATE_CLIENTE
AFTER UPDATE ON CLIENTE_TOTAL_PAGAMENTO FOR EACH ROW
BEGIN
	DECLARE descricao VARCHAR(500) DEFAULT '';
    
    SET descricao = '';

    IF NOT OLD.NOMEEMPREGADO <=> NEW.NOMEEMPREGADO THEN
        SET descricao = CONCAT(descricao, 'Nome do Empregado: "', OLD.NOMEEMPREGADO, '" -> "', NEW.NOMEEMPREGADO, '"; ');
    END IF;

    IF NOT OLD.TOTALPAGAMENTO <=> NEW.TOTALPAGAMENTO THEN
        SET descricao = CONCAT(descricao, 'Total Pagamento: "', OLD.TOTALPAGAMENTO, '" -> "', NEW.TOTALPAGAMENTO, '"; ');
    END IF;

    IF NOT OLD.QTDE_CLIENTE <=> NEW.QTDE_CLIENTE THEN
        SET descricao = CONCAT(descricao, 'Qtd. Clientes: "', OLD.QTDE_CLIENTE, '" -> "', NEW.QTDE_CLIENTE, '"; ');
    END IF;

    IF NOT OLD.ESCRITORIO <=> NEW.ESCRITORIO THEN
        SET descricao = CONCAT(descricao, 'Escritório: "', OLD.ESCRITORIO, '" -> "', NEW.ESCRITORIO, '"; ');
    END IF;

    IF NOT OLD.SITUACAOESCRITORIO <=> NEW.SITUACAOESCRITORIO THEN
        SET descricao = CONCAT(descricao, 'Situação Escritório: "', OLD.SITUACAOESCRITORIO, '" -> "', NEW.SITUACAOESCRITORIO, '"; ');
    END IF;

    IF descricao != '' THEN
        INSERT INTO LOG_CLIENTE_TOTAL_PAGO (DESCRICAO, DATA)
        VALUES (descricao, CURRENT_TIMESTAMP());
    END IF;
END%
DROP PROCEDURE IF EXISTS INSERIR_CLIENTE_TOTAL%
CREATE PROCEDURE INSERIR_CLIENTE_TOTAL()
BEGIN
	DECLARE VAR_FINALIZADO BOOL DEFAULT FALSE;
    DECLARE VAR_NOMEESCRITORIO VARCHAR(50);
    DECLARE VAR_SITUACAOESCRITORIO VARCHAR(100);
    DECLARE VAR_ID_EMPREGADO INT;
    
    DECLARE CURSOR_PEGAR_EMPREGADO CURSOR FOR
    SELECT CODIGOEMPREGADO FROM CLIENTE_ESCRITORIO_TOTAL;
    
    DECLARE CONTINUE HANDLER
		FOR NOT FOUND SET VAR_FINALIZADO = TRUE;
	
    OPEN CURSOR_PEGAR_EMPREGADO;
    
    LISTA: LOOP
		FETCH CURSOR_PEGAR_EMPREGADO INTO VAR_ID_EMPREGADO;
        IF (VAR_FINALIZADO = TRUE) THEN
			LEAVE LISTA;
		END IF;
        
		SELECT
			NOMEEMPREGADO,
			CALCULAR_VALOR_PRECO(CIDADEESCRITORIO,TOTALPAGAMENTO)
			INTO
			VAR_NOMEESCRITORIO,
			VAR_SITUACAOESCRITORIO
		FROM
			CLIENTE_ESCRITORIO_TOTAL
		WHERE 
			CODIGOEMPREGADO = VAR_ID_EMPREGADO
		LIMIT 1;
			
		IF VAR_NOMEESCRITORIO IS NOT NULL AND VAR_SITUACAOESCRITORIO IS NOT NULL THEN
			UPDATE CLIENTE_TOTAL_PAGAMENTO
			SET ESCRITORIO = VAR_NOMEESCRITORIO, SITUACAOESCRITORIO = VAR_SITUACAOESCRITORIO
			WHERE CODIGOEMPREGADO = VAR_ID_EMPREGADO;
		END IF;
    END LOOP;
    
    CLOSE CURSOR_PEGAR_EMPREGADO;
    
    SELECT * FROM CLIENTE_TOTAL_PAGAMENTO;
END%
DELIMITER ;

START TRANSACTION;
CALL INSERIR_CLIENTE_TOTAL();
ROLLBACK;
COMMIT;