Der Ausdruck stringexpression = '' ergibt:
TRUE .. für '' (oder für beliebige Zeichenfolge, die nur aus Leerzeichen besteht, mit dem Datentyp char(n) )NULL .. für NULL FALSE .. für alles andere
Also zu prüfen auf:"stringexpression ist entweder NULL oder leer" :
(stringexpression = '') IS NOT FALSE
Oder der umgekehrte Ansatz (möglicherweise einfacher zu lesen):
(stringexpression <> '') IS NOT TRUE
Funktioniert für jeden Zeichentyp einschließlich char(n) . Das Handbuch über Vergleichsoperatoren.
Oder Verwenden Sie Ihren ursprünglichen Ausdruck ohne trim() , was kostspieliges Rauschen für char(n) ist (siehe unten) oder falsch für andere Zeichentypen:Zeichenfolgen, die nur aus Leerzeichen bestehen, würden als leere Zeichenfolge übergeben.
coalesce(stringexpression, '') = ''
Aber die Ausdrücke ganz oben sind schneller.
Noch einfacher ist es, das Gegenteil zu behaupten:"stringexpression ist weder NULL noch leer" :
stringexpression <> ''
Über char(n)
Hier geht es um den Datentyp char(n) , kurz für:character(n) . (char / character stehen kurz für char(1) / character(1) .) Von seiner Verwendung in Postgres wird abgeraten:
In den meisten Situationen text oder character varying sollte stattdessen verwendet werden.
Verwechseln Sie char(n) nicht mit anderen, nützlichen Zeichentypen varchar(n) , varchar , text oder "char" (mit doppelten Anführungszeichen).
In character(n) eine leere Zeichenkette unterscheidet sich nicht von anderen Zeichenfolgen, die nur aus Leerzeichen bestehen. All dies wird zu n gefaltet Leerzeichen in char(n) pro Definition des Typs. Daraus folgt logischerweise, dass die obigen Ausdrücke für char(n) funktionieren ebenso - genauso viel wie diese (die für andere Charaktertypen nicht funktionieren würden):
coalesce(stringexpression, ' ') = ' '
coalesce(stringexpression, '') = ' '
Demo
Eine leere Zeichenfolge ist gleich einer beliebigen Zeichenfolge aus Leerzeichen, wenn sie in char(n) umgewandelt wird :
SELECT ''::char(5) = ''::char(5) AS eq1
, ''::char(5) = ' '::char(5) AS eq2
, ''::char(5) = ' '::char(5) AS eq3;
Ergebnis:
eq1 | eq2 | eq3
----+-----+----
t | t | t
Testen Sie mit char(n) auf "null oder leere Zeichenfolge". :
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);
Ergebnis:
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
Testen Sie mit text auf "null oder leere Zeichenfolge". :
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);
Ergebnis:
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<>hier fummeln
Altes sqlfiddle
Verwandte:
- Irgendwelche Nachteile bei der Verwendung des Datentyps „Text“ zum Speichern von Strings?
