La mejor forma de comprobar si está “vacío o null valor”

Ten en cuenta que en las ciencias un problema casi siempere suele tener varias resoluciones, pero nosotros aquí te mostraremos lo más óptimo y eficiente.

Solución:

La expresion stringexpression = '' rinde:

TRUE .. por '' (o por alguna string que consta solo de espacios con el tipo de datos char(n))
NULL .. por NULL
FALSE .. para cualquier otra cosa

Entonces para verificar: “stringexpression es NULL o está vacío “:

(stringexpression = '') IS NOT FALSE

O el enfoque inverso (puede ser más fácil de leer):

(stringexpression <> '') IS NOT TRUE

Funciona para cualquier tipo de personaje, incluido char(n). El manual sobre operadores de comparación.

O usa tu expresión original sin trim(), que es un ruido costoso para char(n) (ver más abajo), o incorrecto para otros tipos de caracteres: las cadenas que constan solo de espacios pasarían como vacías string.

coalesce(stringexpression, '') = ''

Pero las expresiones en la parte superior son más rápidas.

Afirmar lo contrario es aún más simple: “stringexpression no es NULL ni está vacío “:

stringexpression <> ''

Sobre char(n)

Se trata del tipo de datos char(n), corto para: character(n). (char / character son cortos para char(1) / character(1).) Se desaconseja su uso en Postgres:

En la mayoría de situaciones text o character varying debe usarse en su lugar.

No confundir char(n) con otros tipos de personajes útiles varchar(n), varchar, text o "char" (con comillas dobles).

En char(n) un vacío string no es diferente a cualquier otro string que consta de solo espacios. Todos estos se doblan para norte espacios en char(n) por definición del tipo. De ello se deduce lógicamente que las expresiones anteriores funcionan para char(n) también, tanto como estos (que no funcionarían para otros tipos de personajes):

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

Manifestación

Vacío string es igual a cualquiera string de espacios cuando se lanza a 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

Hacer una prueba por “null o vacio string” con 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:

 stringexpression | base_test | test1 | test2 | 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

Hacer una prueba por “null o vacio string” con 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:

 stringexpression | base_test | test1 | test2 | 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 <> violín aquí
_{Viejo sqlfiddle}

Relacionado:

• ¿Alguna desventaja de usar el tipo de datos “texto” para almacenar cadenas?

Para comprobar null y vacio:

coalesce(string, '') = ''

Para comprobar null, vacíos y espacios (recortar el string)

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

Comprobando la longitud del string también funciona y es compacto:

where length(stringexpression) > 0;

Al final de todo puedes encontrar las explicaciones de otros administradores, tú de igual forma tienes la habilidad dejar el tuyo si lo crees conveniente.

---

---

Utiliza Nuestro Buscador