L'expression stringexpression = '' donne :
TRUE .. pour '' (ou pour tout chaîne composée uniquement d'espaces avec le type de données char(n) )NULL .. pour NULL FALSE .. pour autre chose
Donc, pour vérifier :"stringexpression est soit NULL soit vide" :
(stringexpression = '') IS NOT FALSE
Ou l'approche inverse (peut être plus facile à lire) :
(stringexpression <> '') IS NOT TRUE
Fonctionne pour tout type de caractère, y compris char(n) . Le manuel sur les opérateurs de comparaison.
Ou utilisez votre expression originale sans trim() , ce qui est un bruit coûteux pour char(n) (voir ci-dessous), ou incorrect pour les autres types de caractères :les chaînes composées uniquement d'espaces passeraient pour une chaîne vide.
coalesce(stringexpression, '') = ''
Mais les expressions en haut sont plus rapides.
Affirmer le contraire est encore plus simple :"stringexpression n'est ni NULL ni vide" :
stringexpression <> ''
À propos de char(n)
Il s'agit du type de données char(n) , abréviation de :character(n) . (char / char sont l'abréviation de char(1) / character(1) .) Son utilisation est déconseillée dans Postgres :
Dans la plupart des situations
textoucharacter varyingdevrait être utilisé à la place.
Ne confondez pas char(n) avec d'autres types de caractères utiles varchar(n) , varchar , text ou "char" (avec guillemets doubles).
Dans char(n) une chaîne vide n'est pas différent de toute autre chaîne composée uniquement d'espaces. Tous ces éléments sont pliés en n espaces dans char(n) par définition du type. Il s'ensuit logiquement que les expressions ci-dessus fonctionnent pour char(n) ainsi - autant que ceux-ci (qui ne fonctionneraient pas pour d'autres types de caractères) :
coalesce(stringexpression, ' ') = ' '
coalesce(stringexpression, '') = ' '
Démo
Une chaîne vide équivaut à n'importe quelle chaîne d'espaces lorsqu'elle est convertie en char(n) :
SELECT ''::char(5) = ''::char(5) AS eq1
, ''::char(5) = ' '::char(5) AS eq2
, ''::char(5) = ' '::char(5) AS eq3;
Résultat :
eq1 | eq2 | eq3
----+-----+----
t | t | t
Testez "chaîne nulle ou vide" avec 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);
Résultat :
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
Testez "chaîne nulle ou vide" avec 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);
Résultat :
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<>jouez ici
Vieux sqlfiddle
Connexe :
- Y a-t-il des inconvénients à utiliser le type de données "texte" pour stocker des chaînes ?
