Melhor maneira de verificar "valor vazio ou nulo"

Qual é a melhor maneira de verificar se o valor é nulo ou vazio nas instruções sql do Postgres?

O valor pode ser uma expressão longa, portanto é preferível que ele seja gravado apenas uma vez em cheque.

Atualmente estou usando:

coalesce( trim(stringexpression),'')=''

Mas parece um pouco feio.

stringexpressionpode ser char(n)coluna ou expressão contendo char(n)colunas com espaços à direita.

Qual é a melhor maneira?

A expressão stringexpression = ''produz:

TRUE   .. for ''(ou para qualquer sequência que consiste apenas em espaços com o tipo de dados char(n))
NULL   .. forNULL
FALSE .. para qualquer outra coisa

Portanto, para verificar: " stringexpressioné NULL ou vazio" :

(stringexpression = '') IS NOT FALSE

Ou a abordagem inversa (pode ser mais fácil de ler):

(stringexpression <> '') IS NOT TRUE

Funciona para qualquer tipo de personagem, incluindo char(n). O manual sobre operadores de comparação.

Ou use sua expressão original sem trim(), que é um ruído dispendioso para char(n)(veja abaixo) ou incorreta para outros tipos de caracteres: cadeias que consistem em apenas espaços passariam como cadeias vazias.

coalesce(stringexpression, '') = ''

Mas as expressões no topo são mais rápidas.

Afirmar o contrário é ainda mais simples: " stringexpressionnão é NULL nem vazio" :

stringexpression <> ''

Sobre char(n)

Isto é sobre o tipo de dados char(n), abreviação de: character(n). ( char/ characteré a abreviação de char(1)/ character(1).) Seu uso é desencorajado no Postgres :

Na maioria das situações, textou character varyingdeve ser usado em seu lugar.

Não confundir char(n)com tipos de outro, útil, caráter varchar(n), varchar, textou"char" (com aspas).

Em char(n)uma cadeia vazia não é diferente de qualquer outra cadeia que consiste apenas em espaços. Todos esses itens são dobrados em n espaços, char(n)por definição do tipo. Segue-se logicamente que as expressões acima funcionam char(n)também - exatamente como essas (que não funcionariam para outros tipos de caracteres):

coalesce(stringexpression, '  ') = '  '
coalesce(stringexpression, '') = '       '

Demo

Cadeia vazia é igual a qualquer cadeia de espaços quando convertida para char(n):

SELECT ''::char(5) = ''::char(5)     AS eq1
     , ''::char(5) = '  '::char(5)   AS eq2
     , ''::char(5) = '    '::char(5) AS eq3;

Resultado:

 eq1 | eq2 | eq3
 ----+-----+----
 t   | t   | t

Teste para "cadeia nula ou vazia" com char(n):

SELECT stringexpression 
     , stringexpression = ''                   AS base_test
     , (stringexpression = '')  IS NOT FALSE   AS test1
     , (stringexpression <> '') IS NOT TRUE    AS test2
     , coalesce(stringexpression, '') = ''     AS coalesce1
     , coalesce(stringexpression, '  ') = '  ' AS coalesce2
     , coalesce(stringexpression, '') = '  '   AS coalesce3
FROM  (
   VALUES
     ('foo'::char(5))
   , ('')
   , ('   ')                -- not different from '' in char(n)
   , (NULL)
   ) sub(stringexpression);

Resultado:

expressão de cadeia | base_test | teste1 | teste2 | coalesce1 | coalesce2 | coalesce3
------------------ + ----------- + ------- + ------- + --- -------- + ----------- + -----------
 foo | f f f f f f
                  | t t t t t t
                  | t t t t t t
 null              | null       | t t t t t

Teste para "cadeia nula ou vazia" com text:

SELECT stringexpression 
     , stringexpression = ''                   AS base_test
     , (stringexpression = '')  IS NOT FALSE   AS test1
     , (stringexpression <> '') IS NOT TRUE    AS test2
     , coalesce(stringexpression, '') = ''     AS coalesce1
     , coalesce(stringexpression, '  ') = '  ' AS coalesce2
     , coalesce(stringexpression, '') = '  '   AS coalesce3
FROM  (
   VALUES
     ('foo'::text)
   , ('')
   , ('   ')                -- different from '' in a sane character types
   , (NULL)
   ) sub(stringexpression);

Resultado:

expressão de cadeia | base_test | teste1 | teste2 | coalesce1 | coalesce2 | coalesce3
------------------ + ----------- + ------- + ------- + --- -------- + ----------- + -----------
 foo | f f f f f f
                  | t t t t f f
                  | f f f f f f
 null              | null       | t t t t f

db <> _mexe aqui
_{Old sqlfiddle}

Palavras-chave:

• Alguma desvantagem de usar o tipo de dados "texto" para armazenar seqüências de caracteres?

Para verificar nulos e vazios:

coalesce(string, '') = ''

Para verificar nulos, vazios e espaços (apare a sequência)

coalesce(TRIM(string), '') = ''

A verificação do comprimento da string também funciona e é compacta:

where length(stringexpression) > 0;

Se houver espaços vazios vazios, provavelmente não há solução melhor. COALESCEé apenas para problemas como o seu.

Algo que eu vi pessoas usando é stringexpression > '' . Pode não ser o mais rápido, mas é um dos mais curtos.

Tentei no MS SQL, bem como no PostgreSQL.

outra maneira é

nullif(trim(stringExpression),'') is not null

Minha maneira preferida de comparar campos anuláveis ​​é: NULLIF (nullablefield,: ParameterValue) É NULL AND NULLIF (: ParameterValue, nullablefield) É NULL. Isso é complicado, mas é de uso universal, enquanto Coalesce é impossível em alguns casos.

O segundo e inverso uso de NULLIF é porque "NULLIF (campo nulo:: ParameterValue) É NULL" sempre retornará "true" se o primeiro parâmetro for nulo.

Se o banco de dados tiver um grande número de registros, null checkpode levar mais tempo, você pode usar a verificação nula de diferentes maneiras, como: 1) where columnname is null 2) where not exists() 3)WHERE (case when columnname is null then true end)

Muitas das respostas são a maneira mais curta, não necessariamente a melhor, se a coluna tiver muitos valores nulos. A interrupção das verificações permite que o otimizador avalie a verificação mais rapidamente, pois não precisa trabalhar na outra condição.

(stringexpression IS NOT NULL AND trim(stringexpression) != '')

A comparação de cadeias não precisa ser avaliada, pois a primeira condição é falsa.