La expresion stringexpression = '' produce:
TRUE .. for ''(o para cualquier cadena que consista solo en espacios con el tipo de datos char(n))
NULL .. forNULL
FALSE ... para cualquier otra cosa
Para verificar: " stringexpressiones 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 use su 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 consisten en solo espacios pasarían como cadenas vacías.
coalesce(stringexpression, '') = ''
Pero las expresiones en la parte superior son más rápidas.
Afirmar lo contrario es aún más simple: " stringexpressionno es NULL ni está vacío" :
stringexpression <> ''
Esto es sobre el tipo de datos char(n), la abreviatura de: character(n). ( char/ characterson la abreviatura de char(1)/ character(1).) Se desaconseja su uso en Postgres :
En la mayoría de las situaciones texto character varyingdebería usarse en su lugar.
No se debe confundir char(n)con otro tipo, útil, carácter varchar(n), varchar, texto"char" (con comillas dobles).
En char(n)una cadena vacía no es diferente de cualquier otra cadena que consista solo en espacios. Todos estos se pliegan en n espacios en char(n)cada definición del tipo. Se deduce lógicamente que las expresiones anteriores también funcionan char(n), tanto como estas (que no funcionarían para otros tipos de caracteres):
coalesce(stringexpression, ' ') = ' '
coalesce(stringexpression, '') = ' '
Manifestación
La cadena vacía equivale a cualquier cadena 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
Prueba de "cadena nula o vacía" 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 | prueba_base | prueba1 | test2 | coalesce1 | coalesce2 | coalesce3
------------------ + ----------- + ------- + ------- + --- -------- + ----------- + -----------
foo | f | f | f | f | f | F
El | t | t | t | t | t | t
El | t | t | t | t | t | t
nulo | nulo | t | t | t | t | t
Prueba de "cadena nula o vacía" 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 | prueba_base | prueba1 | test2 | coalesce1 | coalesce2 | coalesce3
------------------ + ----------- + ------- + ------- + --- -------- + ----------- + -----------
foo | f | f | f | f | f | F
El | t | t | t | t | f | F
El | f | f | f | f | f | F
nulo | nulo | t | t | t | t | F
db <> violín aquí
Viejo sqlfiddle
Relacionado:
chares casi siempre la elección incorrecta debido al relleno (y al desperdicio de espacio resultante). Pero aparte de eso: no creo que haya una mejor solución.