Instruções da PL/pgSQL compatíveis

IF ... THEN

IF boolean-expression THEN
  statements
END IF;

Por exemplo:

IF v_user_id <> 0 THEN
  UPDATE users SET email = v_email WHERE user_id = v_user_id;
END IF;               

IF ... THEN ... ELSE

IF boolean-expression THEN
  statements
ELSE
  statements
END IF;

Por exemplo:

IF parentid IS NULL OR parentid = ''
THEN
  return_name = fullname;
  RETURN;
ELSE
  return_name = hp_true_filename(parentid) || '/' || fullname;
  RETURN;
END IF;           

IF ... THEN ... ELSIF ... THEN ... ELSE

A palavra-chave ELSIF também pode ser escrita como ELSEIF.

IF boolean-expression THEN
  statements
[ ELSIF boolean-expression THEN
  statements
[ ELSIF boolean-expression THEN
  statements
    ...] ]
[ ELSE
  statements ]
END IF;

Por exemplo:

IF number = 0 THEN
  result := 'zero';
ELSIF number > 0 THEN
  result := 'positive';
ELSIF number < 0 THEN
  result := 'negative';
ELSE
  -- the only other possibility is that number is null
  result := 'NULL';
END IF;                  

CASE simples

CASE search-expression
WHEN expression [, expression [ ... ]] THEN
  statements
[ WHEN expression [, expression [ ... ]] THEN
  statements
  ... ]
[ ELSE
  statements ]
END CASE;

Uma instrução CASE simples oferece execução condicional com base na igualdade dos operandos.

O valor search-expression é avaliado uma vez e comparado sucessivamente com cada expression nas cláusulas WHEN. Se uma correspondência for encontrada, as statements correspondentes são executadas e o controle passa para a próxima instrução após END CASE. As expressões WHEN subsequentes não são avaliadas. Se nenhuma correspondência for encontrada, as statements ELSE são executadas. No entanto, se ELSE não estiver presente, uma exceção CASE_NOT_FOUND será gerada.

Por exemplo:

CASE x
WHEN 1, 2 THEN
  msg := 'one or two';
ELSE
  msg := 'other value than one or two';
END CASE;                  

CASE pesquisado

CASE
WHEN boolean-expression THEN
  statements
[ WHEN boolean-expression THEN
  statements
  ... ]
[ ELSE
  statements ]
END CASE;

A formato pesquisado de CASE oferece execução condicional baseada na veracidade de expressões boolianas.

A boolean-expression de cada cláusula WHEN é, por sua vez, avaliada até uma verdadeira ser encontrada. Depois, as instruções correspondentes são executadas e o controle passa para a próxima instrução após END CASE. As expressions WHEN subsequentes não são avaliadas. Se nenhum resultado verdadeiro for encontrado, as statements ELSE são executadas. No entanto, se ELSE não estiver presente, uma exceção CASE_NOT_FOUND será gerada.

Por exemplo:

CASE
WHEN x BETWEEN 0 AND 10 THEN
  msg := 'value is between zero and ten';
WHEN x BETWEEN 11 AND 20 THEN
  msg := 'value is between eleven and twenty';
END CASE;                                

Loop simples

[<<label>>]
LOOP
  statements
END LOOP [ label ];

Um loop simples define um loop não condicional que é repetido indefinidamente até ser encerrado por uma instrução EXIT ou RETURN. O rótulo opcional pode ser usado pelas instruções EXIT e CONTINUE dentro de loops aninhados para especificar a qual loop as instruções EXIT e CONTINUE se referem.

Por exemplo:

CREATE OR REPLACE PROCEDURE simple_loop()
LANGUAGE plpgsql
AS $$
BEGIN
  <<simple_while>>
  LOOP
    RAISE INFO 'I am raised once';  
    EXIT simple_while;
    RAISE INFO 'I am not raised';
  END LOOP;
  RAISE INFO 'I am raised once as well';
END;
$$;                

Loop de saída

EXIT [ label ] [ WHEN expression ];

Se label não estiver presente, o loop mais interno será encerrado e a instrução após END LOOP será executada na sequência. Se label estiver presente, deverá ser o rótulo do loop atual ou de algum outro nível de loop ou bloco aninhado. Depois, o loop ou bloco nomeado será encerrado e o controle continuará com a instrução após END do loop ou bloco correspondente.

Se WHEN for especificada, a saída do loop ocorrerá apenas se a expression for verdadeira. Caso contrário, o controle passa para a instrução após EXIT.

Você pode usar EXIT com todos os tipos de loops, seu uso não se limita a loops não condicionais.

Quando usado com um bloco BEGIN, EXIT passa o controle para a próxima instrução após o final do bloco. Um rótulo pode ser usado para essa finalidade. Um EXIT sem rótulo nunca corresponderá a um bloco BEGIN.

Por exemplo:

CREATE OR REPLACE PROCEDURE simple_loop_when(x int)
LANGUAGE plpgsql
AS $$
DECLARE i INTEGER := 0;
BEGIN
  <<simple_loop_when>>
  LOOP
    RAISE INFO 'i %', i;
    i := i + 1;
    EXIT simple_loop_when WHEN (i >= x);
  END LOOP;
END;
$$;                     

Loop de continuação

CONTINUE [ label ] [ WHEN expression ];

Se label não for fornecido, a execução pulará para a próxima iteração do loop mais interno. Ou seja, todas as instruções restantes no corpo do loop serão ignoradas. Depois, o controle retornará para a expressão de controle do loop (se houver) a fim de determinar se há necessidade de outra iteração do loop. Se label estiver presente, ele especifica o rótulo do loop cuja execução será continuada.

Se WHEN for especificado, a próxima iteração do loop começará somente se a expression for verdadeira. Caso contrário, o controle passa para a instrução após CONTINUE.

Você pode usar CONTINUE com todos os tipos de loops, seu uso não se limita a loops não condicionais.

CONTINUE mylabel;

Loop WHILE

[<<label>>]
WHILE expression LOOP
  statements
END LOOP [ label ];

A instrução WHILE repete uma sequência de instruções até a boolean-expression ser avaliada como verdadeira. A expressão é verificada imediatamente antes de cada entrada no corpo do loop.

Por exemplo:

WHILE amount_owed > 0 AND gift_certificate_balance > 0 LOOP
  -- some computations here
END LOOP;

WHILE NOT done LOOP
  -- some computations here
END LOOP;                  

Loop FOR (variante inteiro)

[<<label>>]
FOR name IN [ REVERSE ] expression .. expression LOOP
  statements
END LOOP [ label ];

O loop FOR (variante inteiro) cria um loop que itera sobre um intervalo de valores inteiros. O nome da variável é definido automaticamente como o tipo inteiro e exite somente dentro do loop. Qualquer definição existente do nome da variável será ignorada dentro do loop. As duas expressões que fornecem os limites superior e inferior do intervalo são avaliadas uma vez ao entrar no loop. Se você especificar REVERSE, o valor da etapa será subtraído, em vez de adicionado, após cada iteração.

Se o limite inferior for maior que o limite superior (ou menor no caso REVERSE), o corpo do loop não será executado. Nenhum erro será gerado.

Se um rótulo for anexado ao loop FOR, você pode referenciar a variável de loop inteira com um nome qualificado, usando esse rótulo.

Por exemplo:

FOR i IN 1..10 LOOP
  -- i will take on the values 1,2,3,4,5,6,7,8,9,10 within the loop
END LOOP;

FOR i IN REVERSE 10..1 LOOP
  -- i will take on the values 10,9,8,7,6,5,4,3,2,1 within the loop
END LOOP;                

Loop FOR (variante conjunto de resultados)

[<<label>>]
FOR target IN query LOOP
  statements
END LOOP [ label ];

O target é uma variável de registro ou lista separada por vírgulas de variáveis escalares. O destino recebe todas as linhas resultantes da consulta e o corpo do loop é executado para cada linha.

O loop FOR (variante conjunto de resultados) habilita a iteração de um procedimento armazenado pelos resultados de uma consulta e manipula os dados de acordo.

Por exemplo:

CREATE PROCEDURE cs_refresh_reports() AS $$
DECLARE
  reports RECORD;
BEGIN
  FOR reports IN SELECT * FROM cs_reports ORDER BY sort_key LOOP
    -- Now "reports" has one record from cs_reports
    EXECUTE 'INSERT INTO ' || quote_ident(reports.report_name) || ' ' || reports.report_query;
  END LOOP;
  RETURN;
END;
$$ LANGUAGE plpgsql;                   

Loop FOR com SQL dinâmico

[<<label>>]
FOR record_or_row IN EXECUTE text_expression LOOP 
  statements
END LOOP;

Um loop FOR com SQL dinâmico habilita a iteração de um procedimento armazenado pelos resultados de uma consulta dinâmica e manipula os dados de acordo.

Por exemplo:

CREATE OR REPLACE PROCEDURE for_loop_dynamic_sql(x int)
LANGUAGE plpgsql
AS $$
DECLARE
  rec RECORD;
  query text;
BEGIN
  query := 'SELECT * FROM tbl_dynamic_sql LIMIT ' || x;
  FOR rec IN EXECUTE query
  LOOP
    RAISE INFO 'a %', rec.a;
  END LOOP;
END;
$$;

Abrir para seleção: a variável de cursor é aberta e recebe a consulta especificada para execução. O cursor não pode já estar aberto. Além disso, ele deverá ter sido declarado como um cursor não associado (isto é, como uma variável refcursor simples). A consulta SELECT é tratada da mesma maneira que outras instruções SELECT na PL/pgSQL.

OPEN cursor_name FOR SELECT ...;                     

Por exemplo:

OPEN curs1 FOR SELECT * FROM foo WHERE key = mykey;    

Abrir para execução: a variável de cursor é aberta e recebe a consulta especificada para execução. O cursor não pode já estar aberto. Além disso, ele deverá ter sido declarado como um cursor não associado (isto é, como uma variável refcursor simples). A consulta é especificada como uma expressão de string da mesma maneira que no comando EXECUTE. Essa abordagem oferece flexibilidade para que a consulta possa variar de uma execução para a próxima.

OPEN cursor_name FOR EXECUTE query_string;

Por exemplo:

OPEN curs1 FOR EXECUTE 'SELECT * FROM ' || quote_ident($1);

Abrir um cursor associado: essa forma de OPEN é usada para abrir uma variável de cursor cuja consulta foi associada a ela no momento em que foi declarada. O cursor não pode já estar aberto. Uma lista das expressões de valor de argumento reais deverá aparecer se, e somente se, o cursor tiver sido declarado para receber argumentos. Esses valores são substituídos na consulta.

OPEN bound_cursor_name [ ( argument_values ) ];

Por exemplo:

OPEN curs2;
OPEN curs3(42);

FETCH recupera a próxima linha do cursor em um destino. Esse destino pode ser uma variável de linha, uma variável de registro ou uma lista separada por vírgulas de variáveis simples, igual à SELECT INTO. Como na SELECT INTO, é possível verificar a variável especial FOUND para conferir se uma linha foi obtida.

FETCH cursor INTO target;

Por exemplo:

FETCH curs1 INTO rowvar;

CLOSE fecha o portal subjacente a um cursor aberto. Use essa instrução para liberar recursos antes do fim da transação. Você também pode usar essa instrução a fim de liberar a variável de cursor para que possa ser aberta novamente.

CLOSE cursor;

Por exemplo:

CLOSE curs1;