Início / dba / Perguntas / 157691
Accepted
Anil
Asked: 2016-12-10 07:25:16 +0800 CST

(x NÃO É NULO) vs (NÃO x É NULO) no PostgreSQL

  • 772

Por que x IS NOT NULLnão é igual a NOT x IS NULL?

Este código:

CREATE TABLE bug_test (
    id int,
    name text
);

INSERT INTO bug_test
VALUES (1, NULL);

DO $$
DECLARE
    v_bug_test bug_test;
BEGIN
    RAISE NOTICE '%: %', v_bug_test, (v_bug_test IS NULL);
    RAISE NOTICE '%: %', v_bug_test, (v_bug_test IS NOT NULL);
    RAISE NOTICE '%: %', v_bug_test, (NOT v_bug_test IS NULL);

    SELECT *
    INTO v_bug_test
    FROM bug_test
    WHERE id = 1;

    RAISE NOTICE '%: %', v_bug_test, (v_bug_test IS NULL);
    RAISE NOTICE '%: %', v_bug_test, (v_bug_test IS NOT NULL);
    RAISE NOTICE '%: %', v_bug_test, (NOT v_bug_test IS NULL);
END
$$;

DROP TABLE bug_test;

dá a seguinte saída:

(,): t
(,): f
(,): f
(1,): f
(1,): f ???
(1,): t

enquanto eu esperaria obter esta saída:

(,): t
(,): f
(,): f
(1,): f
(1,): t <<<
(1,): t
postgresql null

1 respostas

  1. Best Answer

    Você tem que distinguir duas situações: você compara uma COLUMN com NULL, ou você compara toda a ROW (RECORD) com NULL.

    Considere a seguinte consulta:

    SELECT
    id, 
    txt, 
    txt     IS NULL AS txt_is_null, 
    NOT txt IS NULL AS not_txt_is_null, 
    txt IS NOT NULL AS txt_is_not_null
FROM
    (VALUES
        (1::integer, NULL::text)
    ) 
    AS x(id, txt) ;

    Você consegue isso:

    +----+-----+-------------+-----------------+-----------------+
| id | txt | txt_is_null | not_txt_is_null | txt_is_not_null | 
+----+-----+-------------+-----------------+-----------------+
|  1 |     | t           | f               | f               | 
+----+-----+-------------+-----------------+-----------------+

    Isso é, eu acho, o que você e eu esperaríamos. Você está verificando uma COLUNA contra NULL e obtém "txt IS NOT NULL" e "NOT txt IS NULL" são equivalentes.

    No entanto, se você fizer uma verificação diferente:

    SELECT
    id, 
    txt, 
    x       IS NULL AS x_is_null,
    NOT x   IS NULL AS not_x_is_null,
    x   IS NOT NULL AS x_is_not_null
FROM
    (VALUES
        (1, NULL)
    ) 
    AS x(id, txt) ;

    Então você consegue

    +----+-----+-----------+---------------+---------------+
| id | txt | x_is_null | not_x_is_null | x_is_not_null |
+----+-----+-----------+---------------+---------------+
|  1 |     | f         | t             | f             |
+----+-----+-----------+---------------+---------------+

    Isso pode ser surpreendente. Uma coisa parece razoável (x IS NULL) e (NOT x IS NULL) são o oposto um do outro. A outra coisa (o fato de que nem "x IS NULL" nem "x IS NOT NULL" são verdadeiros) parece estranho.

    No entanto, é isso que a documentação do PostgreSQL diz que deve acontecer:

    Se a expressão tiver valor de linha, IS NULL será verdadeiro quando a própria expressão de linha for nula ou quando todos os campos da linha forem nulos, enquanto IS NOT NULL será verdadeiro quando a própria expressão de linha for não nula e todos os campos da linha forem não nulo. Devido a esse comportamento, IS NULL e IS NOT NULL nem sempre retornam resultados inversos para expressões com valor de linha; em particular, uma expressão com valor de linha que contém campos nulos e não nulos retornará false para ambos os testes. Em alguns casos, pode ser preferível escrever a linha IS DISTINCT FROM NULL ou a linha IS NOT DISTINCT FROM NULL, que simplesmente verificará se o valor geral da linha é nulo sem nenhum teste adicional nos campos da linha.

    Devo confessar que acho que nunca usei uma comparação de valor de linha contra nulo, mas acho que, se houver essa possibilidade, pode haver algum caso de uso para isso. Eu não acho que é comum, de qualquer maneira.

    • 18

relate perguntas