L'espressione stringexpression = '' rendimenti:
TRUE .. per '' (o per qualsiasi stringa composta solo da spazi con il tipo di dati char(n) )NULL .. per NULL FALSE .. per qualsiasi altra cosa
Quindi per verificare:"stringexpression è NULL o vuoto" :
(stringexpression = '') IS NOT FALSE
Oppure l'approccio inverso (potrebbe essere più facile da leggere):
(stringexpression <> '') IS NOT TRUE
Funziona con qualsiasi tipo di carattere incluso char(n) . Il manuale sugli operatori di confronto.
Oppure usa la tua espressione originale senza trim() , che è un rumore costoso per char(n) (vedi sotto) o non corretto per altri tipi di carattere:stringhe composte solo da spazi passerebbero come stringa vuota.
coalesce(stringexpression, '') = ''
Ma le espressioni in alto sono più veloci.
Affermare il contrario è ancora più semplice:"stringexpression non è né NULL né vuoto" :
stringexpression <> ''
Informazioni su char(n)
Si tratta del tipo di dati char(n) , abbreviazione di:character(n) . (char / char sono l'abbreviazione di char(1) / character(1) .) Il suo utilizzo è sconsigliato in Postgres:
Nella maggior parte delle situazioni text o character varying dovrebbe essere usato invece.
Non confondere char(n) con altri tipi di caratteri utili varchar(n) , varchar , text o "char" (tra virgolette).
In char(n) una stringa vuota non è diverso da qualsiasi altra stringa composta solo da spazi. Tutti questi vengono piegati a n spazi in char(n) per definizione del tipo. Ne consegue logicamente che le espressioni precedenti funzionano per char(n) anche - tanto quanto questi (che non funzionerebbero per altri tipi di carattere):
coalesce(stringexpression, ' ') = ' '
coalesce(stringexpression, '') = ' '
Dimostrazione
La stringa vuota è uguale a qualsiasi stringa di spazi quando viene eseguita il cast a char(n) :
SELECT ''::char(5) = ''::char(5) AS eq1
, ''::char(5) = ' '::char(5) AS eq2
, ''::char(5) = ' '::char(5) AS eq3;
Risultato:
eq1 | eq2 | eq3
----+-----+----
t | t | t
Verifica "stringa nulla o vuota" 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);
Risultato:
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
Verifica "stringa nulla o vuota" 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);
Risultato:
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<>gioca qui
Sqlfiddle vecchio
Correlati:
- Qualche aspetto negativo dell'utilizzo del tipo di dati "testo" per la memorizzazione di stringhe?
