Declaração CONTINUE no Oracle PL/SQL: Dominando o Fluxo de Loops

Olá, futuro mestre do PL/SQL! Hoje vamos mergulhar fundo no mundo das estruturas de controle de loop, focando especificamente na declaração CONTINUE. Esta aula vai te dar as ferramentas necessárias para usar essa poderosa estrutura de forma eficaz em seus loops. Prepare-se para uma jornada de aprendizado que vai transformar a maneira como você escreve loops em PL/SQL!

1. Introdução à Declaração CONTINUE

Antes de entrarmos nos detalhes técnicos, vamos entender o conceito básico por trás da declaração CONTINUE.

1.1 O que é a declaração CONTINUE?

Imagine que você está subindo uma escada rolante em um shopping. Normalmente, você subiria um degrau de cada vez até chegar ao topo. Mas e se, por algum motivo, você decidisse pular alguns degraus no meio do caminho? É exatamente isso que a declaração CONTINUE faz em um loop de programação.

A declaração CONTINUE permite que você “pule” para a próxima iteração de um loop antes que todas as instruções dentro dele sejam executadas. É como dizer ao seu código: “Ei, ignore o resto deste ciclo e vá direto para o próximo!”

1.2 Por que usar CONTINUE?

Você pode estar se perguntando: “Por que eu precisaria pular parte de um loop?” Bem, há várias razões:

Eficiência: Às vezes, você pode querer evitar executar certas operações em determinadas iterações do loop para economizar tempo de processamento.
Lógica condicional: CONTINUE permite que você implemente lógicas complexas dentro de loops de forma mais limpa e legível.
Evitar aninhamento excessivo: Em vez de aninhar vários blocos IF, você pode usar CONTINUE para criar um fluxo de controle mais plano e fácil de entender.
Processamento seletivo: Quando você precisa processar apenas alguns itens em uma lista e ignorar outros, CONTINUE é sua melhor amiga.

2. Formas da Declaração CONTINUE

No Oracle PL/SQL, a declaração CONTINUE vem em duas formas principais:

CONTINUE simples
CONTINUE WHEN

Vamos explorar cada uma delas em detalhes.

2.1 CONTINUE Simples

A forma mais básica é simplesmente usar a palavra-chave CONTINUE. Quando o Oracle encontra esta instrução, ele imediatamente pula para o início do próximo ciclo do loop.

Imagine que você está lavando louça. Cada prato representa uma iteração do loop. O processo de lavar um prato tem várias etapas:

Pegar o prato (início do loop)
Ensaboar o prato (primeira parte do loop)
Enxaguar o prato (segunda parte do loop)
Secar o prato (final do loop)

Agora, vamos traduzir isso para o nosso exemplo de código:

DECLARE
  v_contador NUMBER := 0;
BEGIN
  LOOP
    -- Pegar o prato
    v_contador := v_contador + 1;
    
    -- Ensaboar o prato
    DBMS_OUTPUT.PUT_LINE('Antes do CONTINUE, v_contador = ' || v_contador);
    
    -- Verificar se o prato precisa de atenção especial
    IF v_contador < 3 THEN
      CONTINUE;  -- Pular para o próximo prato sem enxaguar ou secar
    END IF;
    
    -- Enxaguar e secar o prato
    DBMS_OUTPUT.PUT_LINE('Depois do CONTINUE, v_contador = ' || v_contador);
    
    -- Verificar se terminamos todos os pratos
    EXIT WHEN v_contador = 5;
  END LOOP;
  
  DBMS_OUTPUT.PUT_LINE('Loop finalizado!');
END;

DECLARE

v_contador NUMBER := 0;

BEGIN

LOOP

-- Pegar o prato

v_contador := v_contador + 1;

-- Ensaboar o prato

DBMS_OUTPUT.PUT_LINE('Antes do CONTINUE, v_contador = ' || v_contador);

-- Verificar se o prato precisa de atenção especial

IF v_contador < 3 THEN

CONTINUE; -- Pular para o próximo prato sem enxaguar ou secar

END IF;

-- Enxaguar e secar o prato

DBMS_OUTPUT.PUT_LINE('Depois do CONTINUE, v_contador = ' || v_contador);

-- Verificar se terminamos todos os pratos

EXIT WHEN v_contador = 5;

END LOOP;

DBMS_OUTPUT.PUT_LINE('Loop finalizado!');

END;

Nesta analogia:

Cada iteração do loop é como pegar um novo prato para lavar.
A primeira mensagem (“Antes do CONTINUE”) é como ensaboar o prato.
O IF com o CONTINUE é como verificar se o prato precisa de atenção especial. Se v_contador < 3, é como se disséssemos “Este prato não precisa ser enxaguado ou seco, vamos para o próximo”.
A segunda mensagem (“Depois do CONTINUE”) é como enxaguar e secar o prato.

Quando executamos este código, o que acontece é:

Para os pratos 1 e 2 (v_contador = 1 e 2):
- Pegamos o prato e o ensaboamos (imprimimos a primeira mensagem)
- Vemos que v_contador < 3, então pulamos direto para o próximo prato (CONTINUE)
- Não enxaguamos nem secamos (a segunda mensagem não é impressa)
Para os pratos 3, 4 e 5 (v_contador = 3, 4 e 5):
- Pegamos o prato e o ensaboamos (imprimimos a primeira mensagem)
- v_contador não é mais < 3, então continuamos o processo
- Enxaguamos e secamos o prato (imprimimos a segunda mensagem)
Quando v_contador = 5, terminamos de lavar todos os pratos e saímos do loop.

É por isso que na saída vemos:

A primeira mensagem para todos os pratos (1 a 5)
A segunda mensagem apenas para os pratos 3, 4 e 5

O CONTINUE é útil quando queremos pular o resto das instruções em uma iteração do loop e ir direto para a próxima iteração. É como dizer “Ignore o resto das instruções para este prato e pegue o próximo”.

2.2 CONTINUE WHEN

O CONTINUE WHEN é uma forma mais concisa de combinar uma condição com a instrução CONTINUE. É como ter um filtro automático que decide se devemos continuar com o resto das tarefas ou pular para a próxima iteração do loop.

Vamos usar um exemplo de preparar sanduíches em uma lanchonete:

DECLARE
  v_sanduiche NUMBER := 0;
BEGIN
  LOOP
    v_sanduiche := v_sanduiche + 1;
    DBMS_OUTPUT.PUT_LINE('Preparando sanduíche número ' || v_sanduiche);
    
    CONTINUE WHEN v_sanduiche < 3;
    
    DBMS_OUTPUT.PUT_LINE('Adicionando ingrediente especial ao sanduíche ' || v_sanduiche);
    
    EXIT WHEN v_sanduiche = 5;
  END LOOP;
  
  DBMS_OUTPUT.PUT_LINE('Todos os sanduíches estão prontos!');
END;

DECLARE

v_sanduiche NUMBER := 0;

BEGIN

LOOP

v_sanduiche := v_sanduiche + 1;

DBMS_OUTPUT.PUT_LINE('Preparando sanduíche número ' || v_sanduiche);

CONTINUE WHEN v_sanduiche < 3;

DBMS_OUTPUT.PUT_LINE('Adicionando ingrediente especial ao sanduíche ' || v_sanduiche);

EXIT WHEN v_sanduiche = 5;

END LOOP;

DBMS_OUTPUT.PUT_LINE('Todos os sanduíches estão prontos!');

END;

Neste exemplo:

Cada iteração do loop representa a preparação de um sanduíche.
O CONTINUE WHEN v_sanduiche < 3 funciona assim:
- Se o número do sanduíche for menor que 3, pulamos para o próximo sanduíche sem adicionar o ingrediente especial.
- Se o número do sanduíche for 3 ou maior, continuamos e adicionamos o ingrediente especial.

A saída seria:

Preparando sanduíche número 1
Preparando sanduíche número 2
Preparando sanduíche número 3
Adicionando ingrediente especial ao sanduíche 3
Preparando sanduíche número 4
Adicionando ingrediente especial ao sanduíche 4
Preparando sanduíche número 5
Adicionando ingrediente especial ao sanduíche 5
Todos os sanduíches estão prontos!

Preparando sanduíche número 1

Preparando sanduíche número 2

Preparando sanduíche número 3

Adicionando ingrediente especial ao sanduíche 3

Preparando sanduíche número 4

Adicionando ingrediente especial ao sanduíche 4

Preparando sanduíche número 5

Adicionando ingrediente especial ao sanduíche 5

Todos os sanduíches estão prontos!

Observe que:

Todos os sanduíches são preparados (a primeira mensagem aparece para todos).
Apenas os sanduíches 3, 4 e 5 recebem o ingrediente especial (a segunda mensagem só aparece para eles).

O CONTINUE WHEN é equivalente a usar um IF com CONTINUE:

IF v_sanduiche < 3 THEN
  CONTINUE;
END IF;

IF v_sanduiche < 3 THEN

CONTINUE;

END IF;

Mas o CONTINUE WHEN é mais conciso e direto, tornando o código mais limpo e fácil de ler.

Esta estrutura é útil quando você quer pular algumas etapas do loop para certos valores, mas continuar normalmente para outros, sem precisar escrever uma estrutura IF completa.

3. CONTINUE em Diferentes Tipos de Loops

A declaração CONTINUE pode ser usada em todos os tipos de loops em PL/SQL. Vamos ver como ela funciona em cada um deles.

3.1 CONTINUE em Loops Simples

Já vimos exemplos de CONTINUE em loops simples. Aqui está outro exemplo, desta vez processando uma lista de números:

DECLARE
  v_soma NUMBER := 0;
BEGIN
  FOR i IN 1..10 LOOP
    CONTINUE WHEN MOD(i, 2) = 0; -- Pula números pares
    v_soma := v_soma + i;
    DBMS_OUTPUT.PUT_LINE('Número ímpar somado: ' || i);
  END LOOP;
  
  DBMS_OUTPUT.PUT_LINE('Soma dos números ímpares: ' || v_soma);
END;

DECLARE

v_soma NUMBER := 0;

BEGIN

FOR i IN 1..10 LOOP

CONTINUE WHEN MOD(i, 2) = 0; -- Pula números pares

v_soma := v_soma + i;

DBMS_OUTPUT.PUT_LINE('Número ímpar somado: ' || i);

END LOOP;

DBMS_OUTPUT.PUT_LINE('Soma dos números ímpares: ' || v_soma);

END;

Este código soma apenas os números ímpares da lista, pulando os pares usando CONTINUE WHEN.

3.2 CONTINUE em Loops WHILE

O CONTINUE também pode ser usado em loops WHILE. Veja este exemplo:

DECLARE
  v_contador NUMBER := 0;
BEGIN
  WHILE v_contador < 10 LOOP
    v_contador := v_contador + 1;
    
    CONTINUE WHEN v_contador IN (4, 6, 8);
    
    DBMS_OUTPUT.PUT_LINE('Valor do contador: ' || v_contador);
  END LOOP;
END;

DECLARE

v_contador NUMBER := 0;

BEGIN

WHILE v_contador < 10 LOOP

v_contador := v_contador + 1;

CONTINUE WHEN v_contador IN (4, 6, 8);

DBMS_OUTPUT.PUT_LINE('Valor do contador: ' || v_contador);

END LOOP;

END;

Este código pula a impressão quando o contador é 4, 6 ou 8.

3.3 CONTINUE em Loops FOR

Em loops FOR, o CONTINUE pode ser especialmente útil para processar coleções de dados. Veja este exemplo usando uma tabela de funcionários:

DECLARE
  CURSOR c_emp IS SELECT employee_id, salary FROM employees;
  v_total_salary NUMBER := 0;
BEGIN
  FOR emp_rec IN c_emp LOOP
    CONTINUE WHEN emp_rec.salary > 10000; -- Ignora salários acima de 10000
    
    v_total_salary := v_total_salary + emp_rec.salary;
    DBMS_OUTPUT.PUT_LINE('ID: ' || emp_rec.employee_id || ', Salário: ' || emp_rec.salary);
  END LOOP;
  
  DBMS_OUTPUT.PUT_LINE('Total de salários (até 10000): ' || v_total_salary);
END;

DECLARE

CURSOR c_emp IS SELECT employee_id, salary FROM employees;

v_total_salary NUMBER := 0;

BEGIN

FOR emp_rec IN c_emp LOOP

CONTINUE WHEN emp_rec.salary > 10000; -- Ignora salários acima de 10000

v_total_salary := v_total_salary + emp_rec.salary;

DBMS_OUTPUT.PUT_LINE('ID: ' || emp_rec.employee_id || ', Salário: ' || emp_rec.salary);

END LOOP;

DBMS_OUTPUT.PUT_LINE('Total de salários (até 10000): ' || v_total_salary);

END;

Este código soma apenas os salários até 10000, ignorando os mais altos.

4. Cuidados ao Usar CONTINUE

Ao usar CONTINUE, é importante ter cuidado para não criar loops infinitos acidentalmente ou lógica confusa. Vamos ver alguns pontos de atenção.

4.1 Evitando Loops Infinitos

Um erro comum é criar um loop infinito usando CONTINUE incorretamente. Por exemplo:

DECLARE
  v_contador NUMBER := 0;
BEGIN
  LOOP
    DBMS_OUTPUT.PUT_LINE('v_contador = ' || v_contador);
    CONTINUE;
    v_contador := v_contador + 1;
    EXIT WHEN v_contador = 5;
  END LOOP;
END;

DECLARE

v_contador NUMBER := 0;

BEGIN

LOOP

DBMS_OUTPUT.PUT_LINE('v_contador = ' || v_contador);

CONTINUE;

v_contador := v_contador + 1;

EXIT WHEN v_contador = 5;

END LOOP;

END;

Neste caso, o CONTINUE fará com que o loop nunca chegue à instrução para incrementar v_contador ou à condição de saída. Resultado? Um loop infinito!

4.2 Posicionamento do CONTINUE

A posição do CONTINUE em seu loop é crucial. Ele deve vir antes da condição de saída se você quiser que a condição de saída seja avaliada em cada iteração.

Veja um exemplo correto:

DECLARE
  v_contador NUMBER := 0;
BEGIN
  LOOP
    v_contador := v_contador + 1;
    
    EXIT WHEN v_contador = 5;
    
    CONTINUE WHEN v_contador > 3;
    
    DBMS_OUTPUT.PUT_LINE('v_contador = ' || v_contador);
  END LOOP;
  
  DBMS_OUTPUT.PUT_LINE('Loop finalizado!');
END;

DECLARE

v_contador NUMBER := 0;

BEGIN

LOOP

v_contador := v_contador + 1;

EXIT WHEN v_contador = 5;

CONTINUE WHEN v_contador > 3;

DBMS_OUTPUT.PUT_LINE('v_contador = ' || v_contador);

END LOOP;

DBMS_OUTPUT.PUT_LINE('Loop finalizado!');

END;

Neste exemplo, a condição de saída é verificada antes do CONTINUE, garantindo que o loop sempre terminará eventualmente.

4.3 Clareza do Código

Embora CONTINUE possa tornar seu código mais eficiente, use-o com moderação. Muitos CONTINUE em um único loop podem tornar o código difícil de entender. Sempre priorize a legibilidade.

5. Casos de Uso Práticos para CONTINUE

Vamos explorar alguns cenários do mundo real onde CONTINUE pode ser muito útil.

5.1 Processamento de Dados Seletivo

Imagine que você está processando uma lista de transações e quer ignorar as que estão abaixo de um certo valor:

DECLARE
  TYPE transacao_rec IS RECORD (
    id NUMBER,
    valor NUMBER
  );
  
  TYPE transacao_list IS TABLE OF transacao_rec;
  
  v_transacoes transacao_list := transacao_list(
    transacao_rec(1, 50),
    transacao_rec(2, 150),
    transacao_rec(3, 75),
    transacao_rec(4, 200),
    transacao_rec(5, 100)
  );
  
  v_total NUMBER := 0;
BEGIN
  FOR i IN 1..v_transacoes.COUNT LOOP
    CONTINUE WHEN v_transacoes(i).valor < 100;
    
    v_total := v_total + v_transacoes(i).valor;
    DBMS_OUTPUT.PUT_LINE('Processada transação ID: ' || v_transacoes(i).id || 
                         ', Valor: ' || v_transacoes(i).valor);
  END LOOP;
  
  DBMS_OUTPUT.PUT_LINE('Total processado: ' || v_total);
END;

DECLARE

TYPE transacao_rec IS RECORD (

id NUMBER,

valor NUMBER

);

TYPE transacao_list IS TABLE OF transacao_rec;

v_transacoes transacao_list := transacao_list(

transacao_rec(1, 50),

transacao_rec(2, 150),

transacao_rec(3, 75),

transacao_rec(4, 200),

transacao_rec(5, 100)

);

v_total NUMBER := 0;

BEGIN

FOR i IN 1..v_transacoes.COUNT LOOP

CONTINUE WHEN v_transacoes(i).valor < 100;

v_total := v_total + v_transacoes(i).valor;

DBMS_OUTPUT.PUT_LINE('Processada transação ID: ' || v_transacoes(i).id ||

', Valor: ' || v_transacoes(i).valor);

END LOOP;

DBMS_OUTPUT.PUT_LINE('Total processado: ' || v_total);

END;

Este código processa apenas transações com valor igual ou superior a 100.

Explicação detalhada do TYPE:

TYPE transacao_rec IS RECORD:
- Aqui, estamos criando um tipo de registro personalizado chamado transacao_rec.
- Um registro é como uma “mini-tabela” com diferentes campos.
- Neste caso, nosso registro tem dois campos: id e valor, ambos do tipo NUMBER.
TYPE transacao_list IS TABLE OF transacao_rec:
- Esta linha cria um novo tipo chamado transacao_list.
- É uma coleção (como uma lista ou array) que pode conter vários elementos do tipo transacao_rec.
- Pense nisso como uma tabela onde cada linha é um transacao_rec.
v_transacoes transacao_list := transacao_list(...):
- Aqui, estamos criando uma variável chamada v_transacoes do tipo transacao_list.
- Estamos inicializando esta variável com cinco elementos, cada um sendo um transacao_rec.

Esta estrutura nos permite trabalhar com uma lista de transações, onde cada transação tem um ID e um valor.

5.2 Validação de Dados

CONTINUE pode ser útil ao validar dados antes de processá-los:

DECLARE
  TYPE cliente_rec IS RECORD (
    id NUMBER,
    nome VARCHAR2(100),
    email VARCHAR2(100)
  );
  
  TYPE cliente_list IS TABLE OF cliente_rec;
  
  v_clientes cliente_list := cliente_list(
    cliente_rec(1, 'João', 'joao@email.com'),
    cliente_rec(2, 'Maria', ''),
    cliente_rec(3, 'Pedro', 'pedro@email.com'),
    cliente_rec(4, 'Ana', 'ana@invalido'),
    cliente_rec(5, 'Carlos', 'carlos@email.com')
  );
  
  v_clientes_validos NUMBER := 0;
  
  FUNCTION email_valido(p_email VARCHAR2) RETURN BOOLEAN IS
  BEGIN
    RETURN REGEXP_LIKE(p_email, '^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}$');
  END;
  
BEGIN
  FOR i IN 1..v_clientes.COUNT LOOP
    CONTINUE WHEN v_clientes(i).email IS NULL OR NOT email_valido(v_clientes(i).email);
    
    v_clientes_validos := v_clientes_validos + 1;
    DBMS_OUTPUT.PUT_LINE('Cliente válido: ' || v_clientes(i).nome || 
                         ', Email: ' || v_clientes(i).email);
  END LOOP;
  
  DBMS_OUTPUT.PUT_LINE('Total de clientes válidos: ' || v_clientes_validos);
END;

DECLARE

TYPE cliente_rec IS RECORD (

id NUMBER,

nome VARCHAR2(100),

email VARCHAR2(100)

);

TYPE cliente_list IS TABLE OF cliente_rec;

v_clientes cliente_list := cliente_list(

cliente_rec(1, 'João', 'joao@email.com'),

cliente_rec(2, 'Maria', ''),

cliente_rec(3, 'Pedro', 'pedro@email.com'),

cliente_rec(4, 'Ana', 'ana@invalido'),

cliente_rec(5, 'Carlos', 'carlos@email.com')

);

v_clientes_validos NUMBER := 0;

FUNCTION email_valido(p_email VARCHAR2) RETURN BOOLEAN IS

BEGIN

RETURN REGEXP_LIKE(p_email, '^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}$');

END;

BEGIN

FOR i IN 1..v_clientes.COUNT LOOP

CONTINUE WHEN v_clientes(i).email IS NULL OR NOT email_valido(v_clientes(i).email);

v_clientes_validos := v_clientes_validos + 1;

DBMS_OUTPUT.PUT_LINE('Cliente válido: ' || v_clientes(i).nome ||

', Email: ' || v_clientes(i).email);

END LOOP;

DBMS_OUTPUT.PUT_LINE('Total de clientes válidos: ' || v_clientes_validos);

END;

Este código valida os emails dos clientes, ignorando os inválidos ou vazios.

Explicação detalhada da função:

FUNCTION email_valido(p_email VARCHAR2) RETURN BOOLEAN IS:
- Esta linha declara uma função chamada email_valido.
- A função aceita um parâmetro p_email do tipo VARCHAR2 (string de caracteres variáveis).
- A função retorna um valor BOOLEAN (verdadeiro ou falso).
RETURN REGEXP_LIKE(p_email, '^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}$');:
- Esta é a única instrução dentro da função.
- Utiliza a função REGEXP_LIKE, que verifica se uma string corresponde a um padrão de expressão regular.
- O primeiro argumento é o email a ser verificado (p_email).
- O segundo argumento é a expressão regular que define o padrão de um email válido.
A expressão regular '^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}$' pode ser decomposta assim:
- ^: Início da string
- [A-Za-z0-9._%+-]+: Um ou mais caracteres que podem ser letras, números, ou alguns símbolos especiais
- @: O símbolo @
- [A-Za-z0-9.-]+: Um ou mais caracteres para o domínio (letras, números, ponto ou hífen)
- \.: Um ponto literal (escapado com $$
- [A-Z|a-z]{2,}: Duas ou mais letras para a extensão do domínio (.com, .org, etc.)
- $: Fim da string
A função retorna TRUE se o email corresponder a este padrão, e FALSE caso contrário.

No contexto do exemplo:

CONTINUE WHEN v_clientes(i).email IS NULL OR NOT email_valido(v_clientes(i).email);

1	CONTINUE WHEN v_clientes(i).email IS NULL OR NOT email_valido(v_clientes(i).email);

Esta linha usa a função email_valido para verificar se o email do cliente é válido. Se o email for nulo OU não for válido (note o NOT antes de email_valido), o loop continuará para o próximo cliente sem processar o atual.

Esta função é uma maneira simples de validar emails usando uma expressão regular. É importante notar que, embora esta expressão regular cubra muitos casos comuns, ela pode não capturar todos os formatos de email válidos ou rejeitar alguns emails incomuns mas válidos. Em um sistema de produção, você pode querer usar uma validação mais robusta ou uma biblioteca especializada para validação de emails.

5.3 Otimização de Performance

CONTINUE pode ajudar a otimizar a performance evitando operações desnecessárias:

DECLARE
  TYPE produto_rec IS RECORD (
    id NUMBER,
    nome VARCHAR2(100),
    preco NUMBER,
    estoque NUMBER
  );
  
  TYPE produto_list IS TABLE OF produto_rec;
  
  v_produtos produto_list := produto_list(
    produto_rec(1, 'Laptop', 1500, 10),
    produto_rec(2, 'Mouse', 50, 0),
    produto_rec(3, 'Teclado', 100, 5),
    produto_rec(4, 'Monitor', 300, 0),
    produto_rec(5, 'Headset', 80, 15)
  );
  
  v_valor_total_estoque NUMBER := 0;
BEGIN
  FOR i IN 1..v_produtos.COUNT LOOP
    CONTINUE WHEN v_produtos(i).estoque = 0;
    
    v_valor_total_estoque := v_valor_total_estoque + (v_produtos(i).preco * v_produtos(i).estoque);
    DBMS_OUTPUT.PUT_LINE('Produto: ' || v_produtos(i).nome || 
                         ', Valor em estoque: ' || (v_produtos(i).preco * v_produtos(i).estoque));
  END LOOP;
  
  DBMS_OUTPUT.PUT_LINE('Valor total em estoque: ' || v_valor_total_estoque);
END;

DECLARE

TYPE produto_rec IS RECORD (

id NUMBER,

nome VARCHAR2(100),

preco NUMBER,

estoque NUMBER

);

TYPE produto_list IS TABLE OF produto_rec;

v_produtos produto_list := produto_list(

produto_rec(1, 'Laptop', 1500, 10),

produto_rec(2, 'Mouse', 50, 0),

produto_rec(3, 'Teclado', 100, 5),

produto_rec(4, 'Monitor', 300, 0),

produto_rec(5, 'Headset', 80, 15)

);

v_valor_total_estoque NUMBER := 0;

BEGIN

FOR i IN 1..v_produtos.COUNT LOOP

CONTINUE WHEN v_produtos(i).estoque = 0;

v_valor_total_estoque := v_valor_total_estoque + (v_produtos(i).preco * v_produtos(i).estoque);

DBMS_OUTPUT.PUT_LINE('Produto: ' || v_produtos(i).nome ||

', Valor em estoque: ' || (v_produtos(i).preco * v_produtos(i).estoque));

END LOOP;

DBMS_OUTPUT.PUT_LINE('Valor total em estoque: ' || v_valor_total_estoque);

END;

Este código calcula o valor total do estoque, ignorando produtos sem estoque para evitar cálculos desnecessários.

Explicação detalhada do TYPE:

TYPE produto_rec IS RECORD:
- Cria um tipo de registro chamado produto_rec.
- Este registro tem quatro campos: id, nome, preco, e estoque.
- Cada produto_rec representa um produto individual com suas características.
TYPE produto_list IS TABLE OF produto_rec:
- Cria um tipo de coleção chamado produto_list.
- Esta coleção pode armazenar múltiplos produto_rec.
- É como uma tabela de produtos, onde cada linha é um produto completo.
v_produtos produto_list := produto_list(...):
- Cria uma variável v_produtos do tipo produto_list.
- Inicializa esta variável com cinco produtos, cada um com seus respectivos dados.

Esta estrutura nos permite trabalhar com uma lista de produtos, onde cada produto tem um ID, nome, preço e quantidade em estoque.

Estas estruturas TYPE nos permitem criar tipos de dados personalizados que se assemelham a tabelas de banco de dados, mas existem apenas na memória durante a execução do programa PL/SQL. Isso nos dá flexibilidade para trabalhar com dados estruturados de forma eficiente.

6. CONTINUE vs. IF-THEN-ELSE

Você pode estar se perguntando: “Por que usar CONTINUE quando posso simplesmente usar um IF-THEN-ELSE?” Boa pergunta! Vamos comparar as duas abordagens.

6.1 Usando IF-THEN-ELSE

Primeiro, vejamos como ficaria nosso exemplo de processamento de transações usando IF-THEN-ELSE:

DECLARE
  TYPE transacao_rec IS RECORD (
    id NUMBER,
    valor NUMBER
  );
  
  TYPE transacao_list IS TABLE OF transacao_rec;
  
  v_transacoes transacao_list := transacao_list(
    transacao_rec(1, 50),
    transacao_rec(2, 150),
    transacao_rec(3, 75),
    transacao_rec(4, 200),
    transacao_rec(5, 100)
  );
  
  v_total NUMBER := 0;
BEGIN
  FOR i IN 1..v_transacoes.COUNT LOOP
    IF v_transacoes(i).valor >= 100 THEN
      v_total := v_total + v_transacoes(i).valor;
      DBMS_OUTPUT.PUT_LINE('Processada transação ID: ' || v_transacoes(i).id || 
                           ', Valor: ' || v_transacoes(i).valor);
    END IF;
  END LOOP;
  
  DBMS_OUTPUT.PUT_LINE('Total processado: ' || v_total);
END;

DECLARE

TYPE transacao_rec IS RECORD (

id NUMBER,

valor NUMBER

);

TYPE transacao_list IS TABLE OF transacao_rec;

v_transacoes transacao_list := transacao_list(

transacao_rec(1, 50),

transacao_rec(2, 150),

transacao_rec(3, 75),

transacao_rec(4, 200),

transacao_rec(5, 100)

);

v_total NUMBER := 0;

BEGIN

FOR i IN 1..v_transacoes.COUNT LOOP

IF v_transacoes(i).valor >= 100 THEN

v_total := v_total + v_transacoes(i).valor;

DBMS_OUTPUT.PUT_LINE('Processada transação ID: ' || v_transacoes(i).id ||

', Valor: ' || v_transacoes(i).valor);

END IF;

END LOOP;

DBMS_OUTPUT.PUT_LINE('Total processado: ' || v_total);

END;

6.2 Comparação

Agora, vamos comparar as duas abordagens:

Legibilidade: Em loops simples, CONTINUE pode tornar o código mais legível, especialmente quando há múltiplas condições para pular.
Aninhamento: CONTINUE reduz o nível de aninhamento do código, o que pode torná-lo mais fácil de ler e manter.
Intenção: CONTINUE comunica claramente a intenção de pular para a próxima iteração, enquanto IF-THEN-ELSE pode ser menos explícito.
Performance: Em termos de performance, não há diferença significativa entre as duas abordagens.
Flexibilidade: IF-THEN-ELSE oferece mais flexibilidade para executar código alternativo quando a condição não é atendida.

Em geral, use CONTINUE quando quiser expressar claramente a intenção de pular uma iteração. Use IF-THEN-ELSE quando precisar de lógica mais complexa ou código alternativo.

7. Melhores Práticas ao Usar CONTINUE

Para aproveitar ao máximo a declaração CONTINUE e evitar armadilhas comuns, siga estas melhores práticas:

Use com moderação: CONTINUE pode tornar o fluxo do código menos óbvio se usado em excesso. Use-o quando realmente simplificar a lógica.
Coloque no início do loop: Quando possível, coloque as declarações CONTINUE no início do loop para tornar o fluxo mais claro.
Comente o propósito: Adicione um comentário breve explicando por que você está usando CONTINUE, especialmente em lógicas complexas.
Evite múltiplos CONTINUE: Se você tem múltiplos CONTINUE em um loop, considere refatorar para simplificar a lógica.
Teste thoroughly: Loops com CONTINUE podem ser tricky. Certifique-se de testar todas as condições possíveis.
Combine com cuidado: Ao usar CONTINUE com outras estruturas de controle como EXIT, certifique-se de que a lógica ainda faz sentido.

8. Exercícios Práticos

Para solidificar seu entendimento, tente estes exercícios:
1. Escreva um loop que processe uma lista de números, pulando os múltiplos de 3 e imprimindo os demais.
2. Crie um loop que processe uma lista de strings, ignorando as strings vazias e convertendo as demais para maiúsculas.
3. Implemente um loop que calcule a soma dos dígitos de cada número em uma lista, pulando os números negativos.
Conclusão

A declaração CONTINUE é uma ferramenta poderosa no arsenal de um desenvolvedor PL/SQL. Ela oferece um meio elegante de controlar o fluxo dentro de loops, permitindo que você ignore iterações específicas com base em condições. Quando usada corretamente, CONTINUE pode tornar seu código mais limpo, mais eficiente e mais fácil de entender.

Lembre-se sempre de usar CONTINUE com cuidado, prestando atenção à sua posição no loop e às condições que o acionam. Com prática e atenção às melhores práticas que discutimos, você se tornará um mestre no uso de CONTINUE para criar loops mais elegantes e eficientes em seus programas PL/SQL.

Agora é com você! Experimente usar CONTINUE em seus próprios projetos. Tente criar alguns loops usando CONTINUE e CONTINUE WHEN. Experimente diferentes posições e condições para ver como isso afeta o comportamento do seu loop. E lembre-se, a prática leva à perfeição!

1. Introdução à Declaração CONTINUE

1.1 O que é a declaração CONTINUE?

1.2 Por que usar CONTINUE?

2. Formas da Declaração CONTINUE

2.1 CONTINUE Simples

2.2 CONTINUE WHEN

3. CONTINUE em Diferentes Tipos de Loops

3.1 CONTINUE em Loops Simples

3.2 CONTINUE em Loops WHILE

3.3 CONTINUE em Loops FOR

4. Cuidados ao Usar CONTINUE

4.1 Evitando Loops Infinitos

4.2 Posicionamento do CONTINUE

4.3 Clareza do Código

5. Casos de Uso Práticos para CONTINUE

5.1 Processamento de Dados Seletivo

5.2 Validação de Dados

5.3 Otimização de Performance

6. CONTINUE vs. IF-THEN-ELSE

6.1 Usando IF-THEN-ELSE

6.2 Comparação

7. Melhores Práticas ao Usar CONTINUE

8. Exercícios Práticos

Conclusão

Related Posts