MongoDB
 sql >> Base de Dados >  >> NoSQL >> MongoDB

SQL COALESCE() Explicado


A maioria dos principais RDBMSs suporta o COALESCE() operador, que retorna o primeiro valor não nulo de sua lista de argumentos.

COALESCE() é um recurso padrão SQL (está incluído na especificação ISO/IEC 9075).

Sintaxe


A sintaxe fica assim:
COALESCE (V1, V2, ..., Vn)

Portanto, pelo menos um argumento é necessário, mas vários argumentos podem ser (e geralmente são) fornecidos.

COALESCE() é considerado um n -operador ádico. Em outras palavras, é um operador que possui um número variável de operandos (ou seja, n operandos).

Exemplo


Aqui está um exemplo simples para demonstrar:
SELECT COALESCE(null, 'Papaya', 'Salad');

Resultado:
Papaya

Neste caso, Papaya foi o primeiro valor não nulo, então COALESCE() retornou esse valor.

Salad também era um valor não nulo, mas veio depois de Papaya e por isso não foi devolvido.

COALESCE() vs CASE


COALESCE() é normalmente considerado um atalho sintático para o CASE expressão.

Assim, a seguinte afirmação:
COALESCE (V1, V2)

é equivalente a:
CASE WHEN V1 IS NOT NULL THEN V1 ELSE V2 END

E a seguinte declaração:
COALESCE (V1, V2, ..., Vn)

(para n ≥ 3) É equivalente a:
CASE WHEN V1 IS NOT NULL THEN V1 ELSE COALESCE (V2, ..., Vn) END

Quando todos os valores são nulos


Se todos os valores forem null , COALESCE() retorna null :
SELECT COALESCE( null, null );

Resultado:
null

Dependendo do seu RDBMS, a saída real para valores nulos pode ser diferente. Por exemplo, ao usar psql (para PostgreSQL), a string vazia é gerada por padrão sempre que um valor nulo é retornado (embora isso possa ser alterado). É o mesmo com o SQLite (e isso também pode ser alterado).

No SQL Server, se todos os argumentos forem null , então pelo menos um dos valores nulos deve ser um null digitado . Portanto, o exemplo acima na verdade resulta em um erro (porque todos os argumentos nulos são null constantes).

Expressões


COALESCE() retorna o valor atual da primeira expressão que inicialmente não é avaliada como null . Portanto, se passarmos uma expressão como esta:
SELECT COALESCE( null, 3 * 5 );

Obtemos isso:
15

Exemplo de banco de dados


Suponha que executemos a seguinte consulta:
SELECT
  name,
  salary
FROM employee;

E obtemos o seguinte resultado:
 name  | salary 
-------+--------
 Elise | 100000
 Rohit |  50000
 Homer |   null

Podemos ver que a última linha tem um valor nulo no DOB coluna.

Se quiséssemos substituir o valor nulo por outro valor, poderíamos usar COALESCE() do seguinte modo:
SELECT
  name,
  COALESCE(salary, 0) AS salary
FROM employee;

Resultado:
 name  | salary 
-------+--------
 Elise | 100000
 Rohit |  50000
 Homer |      0

Neste caso, substituímos todos os valores nulos pelo inteiro 0 .

Diferenças entre RDBMSs


Em geral, COALESCE() funciona praticamente da mesma forma nos RDBMSs.

Mas existem algumas diferenças.

Tipos de dados


Podemos fazer o seguinte no MySQL, MariaDB e SQLite:
SELECT
  name,
  COALESCE(salary, 'None') AS salary
FROM employee;

Resultado:
name	salary
-----   ------
Elise	100000
Rohit	50000
Homer	None

Nesse caso, sempre que o salary coluna contém um valor nulo, a saída é None .

Mas essa consulta pode causar problemas no SQL Server, PostgreSQL ou Oracle Database.

Quando executo essa consulta no SQL Server, PostgreSQL e Oracle Database, recebo um erro devido ao valor substituto ser o tipo de dados incorreto.

Aqui está o que o SQL Server retorna quando executo a consulta acima:
Msg 245, Level 16, State 1, Line 15
Conversion failed when converting the varchar value 'None' to data type int.

Aqui está o que o PostgreSQL retorna:
ERROR:  invalid input syntax for type integer: "None"
LINE 3:   COALESCE(salary, 'None') AS salary
                           ^

E aqui está o que o Oracle Database retorna:
ORA-00932: inconsistent datatypes: expected NUMBER got CHAR

Mas se eu usar um valor numérico, não recebo o erro:
SELECT
  name,
  COALESCE(salary, 0) AS salary
FROM employee;

Resultado:
 name  | salary 
-------+--------
 Elise | 100000
 Rohit |  50000
 Homer |      0

Portanto, este exemplo final funciona em todos os seis RDBMSs acima.

Argumentos nulos


Outra diferença entre como os RDBMSs processam COALESCE() está em como eles lidam com argumentos nulos.

Como mencionado, no SQL Server, se todos os argumentos forem null , pelo menos um dos valores nulos deve ser um null digitado . Em outras palavras, se todos os argumentos para COALESCE() são a constante nula, então obtemos um erro. Este não é o caso de outros RDBMSs, onde todos os argumentos podem ser a constante nula e a saída será null em vez de um erro.