La expresión stringexpression = '' rendimientos:
TRUE .. para '' (o para cualquier cadena que consta solo de espacios con el tipo de datos char(n) )NULL .. para NULL FALSE .. por 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 carácter, 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 a continuación), o incorrecto para otros tipos de caracteres:las cadenas que consisten solo en 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:"stringexpression no es NULL ni está vacío" :
stringexpression <> ''
Acerca de char(n)
Se trata del tipo de datos char(n) , abreviatura de:character(n) . (char / character son abreviaturas de char(1) / character(1) .) Se desaconseja su uso en Postgres:
En la mayoría de las situaciones text o character varying debería usarse en su lugar.
No confundas char(n) con otros tipos de caracteres útiles varchar(n) , varchar , text o "char" (con comillas dobles).
En char(n) una cadena vacía no es diferente de cualquier otra cadena que consista únicamente en espacios. Todos estos se doblan a n espacios en char(n) por definición del tipo. Se sigue 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, '') = ' '
Demostración
La cadena vacía es igual a cualquier cadena de espacios cuando se convierte en 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 | 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
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 | 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í
Sqlfiddle antiguo
Relacionado:
- ¿Alguna desventaja de usar el tipo de datos "texto" para almacenar cadenas?
