A expressão SQL CASE é uma expressão condicional genérica, semelhante a instruções if/else em outras linguagens de programação: ^[83]

CASE WHEN condição THEN resultado
     [WHEN ...]
     [ELSE resultado]
END

As expressões CASE podem ser usadas sempre que uma expressão for válida. Cada condição é uma expressão que retorna um resultado booleano. Se o resultado da condição for verdade, o valor da expressão CASE será o resultado que segue a condição, e o restante da expressão CASE não será processado. Se o resultado da condição não for verdade, as cláusulas WHEN subsequentes serão examinadas da mesma maneira. Se nenhuma cláusula WHEN condição for verdade, o valor da expressão CASE será o resultado da cláusula ELSE. Se a cláusula ELSE for omitida, e nenhuma condição resultar em verdade, o resultado será o valor nulo.

Um exemplo:

CREATE TEMPORARY TABLE teste (a integer);
INSERT INTO teste VALUES (1), (2), (3);
SELECT * FROM teste;

 a
---
 1
 2
 3
(3 linhas)

SELECT a,
       CASE WHEN a=1 THEN 'um'
            WHEN a=2 THEN 'dois'
            ELSE 'outro'
       END
    FROM teste;

 a | case
---+-------
 1 | um
 2 | dois
 3 | outro
(3 linhas)

Os tipos de dados de todas as expressões resultado devem ser conversíveis em um único tipo de dados de saída. Veja a Seção 10.5 para obter mais detalhes.

Existe uma forma “simples” da expressão CASE, que é uma variante da forma geral acima:

CASE expressão
    WHEN valor THEN resultado
    [WHEN ...]
    [ELSE resultado]
END

A primeira expressão é calculada, e então comparada com cada uma das expressões valor nas cláusulas WHEN até encontrar um valor que seja correspondente. Se nenhuma correspondência for encontrada, será retornado o resultado da cláusula ELSE (ou o valor nulo). Esta cláusula é semelhante ao comando switch da linguagem C.

O exemplo acima pode ser escrito usando a sintaxe simples da cláusula CASE:

SELECT a,
       CASE a WHEN 1 THEN 'um'
              WHEN 2 THEN 'dois'
              ELSE 'outro'
       END
    FROM teste;

 a | case
---+-------
 1 | um
 2 | dois
 3 | outro
(3 linhas)

A cláusula CASE não avalia nenhuma subexpressão que não seja necessária para determinar o resultado. Por exemplo, esta é uma maneira possível de evitar um erro de divisão por zero:

SELECT ... WHERE CASE WHEN x <> 0 THEN y/x > 1.5 ELSE false END;

COALESCE(valor [, ...])

A função COALESCE retorna o primeiro de seus argumentos que não for nulo. É retornado o valor nulo somente quando todos os argumentos são nulos. Geralmente é usada para substituir valores nulos por um valor padrão quando os dados são recuperados para exibição, por exemplo: ^[84]

SELECT COALESCE(descricao, descricao_curta, '(nenhuma)') ...

Esta consulta retorna o argumento descricao, caso não seja nulo, senão retorna o argumento descricao_curta, caso não seja nulo, senão retorna (nenhuma).

Os argumentos devem ser todos conversíveis para um tipo de dados comum, que será o tipo de dados do resultado (veja a Seção 10.5 para obter detalhes).

Da mesma forma que a expressão CASE, a expressão COALESCE avalia apenas os argumentos necessários para determinar o resultado; ou seja, os argumentos à direita do primeiro argumento não nulo não são avaliados. Esta função do padrão SQL fornece recursos semelhantes aos das funções NVL e IFNULL, usadas em alguns outros sistemas de banco de dados.

NULLIF(valor1, valor2)

A função NULLIF retorna o valor nulo se valor1 for igual a valor2; senão retorna valor1. Pode ser usada para executar a operação inversa do exemplo COALESCE mostrado acima: ^[85]

SELECT NULLIF(valor, '(none)') ...

Neste exemplo, se valor for (none), retorna nulo, senão retorna valor.

Os dois argumentos devem ser de tipos de dados comparáveis. Sendo específico, os argumentos são comparados exatamente como se tivesse sido escrito valor1 = valor2, então deve haver um operador = disponível.

O resultado tem o mesmo tipo de dados que o primeiro argumento — mas há uma sutileza. O que é realmente retornado é o primeiro argumento do operador = implícito e, em alguns casos, o primeiro argumento será promovido para corresponder ao tipo de dados do segundo argumento. Por exemplo, NULLIF(1, 2.2) resulta em numeric, por não haver operador integer = numeric, há apenas o operador numeric = numeric. Exemplo:

SELECT nullif(1, 2.2), pg_typeof(nullif(1, 2.2));

 nullif | pg_typeof
--------+-----------
      1 | numeric
(1 linha)

GREATEST(valor [, ...])

LEAST(valor [, ...])

As funções GREATEST e LEAST selecionam, respectivamente, o maior e o menor valor de uma lista com qualquer número de expressões. As expressões devem ser todas conversíveis para um tipo de dados comum, que será o tipo de dados do resultado (veja a Seção 10.5 para obter detalhes).

Os valores NULL na lista de argumentos são ignorados. O resultado será NULL somente se todas as expressões forem avaliadas como NULL. (Isto representa um desvio do padrão SQL. Segundo o padrão, o valor retornado será NULL se algum argumento for NULL. Alguns outros sistema de banco de dados se comportam desta forma.)

SELECT LEAST('a', 'ã', 'á', 'à'); → a

SELECT GREATEST('a', 'ã', 'á', 'à'); → ã

SELECT LEAST('José', 'Josué', 'João', 'Joaquim', 'Jonas'); → João

SELECT GREATEST('José', 'Josué', 'João', 'Joaquim', 'Jonas'); → Josué

SELECT GREATEST('José', 'João', NULL, 'Joaquim', 'Jonas'); → José