Der Ausdruck stringexpression = '' ergibt:
TRUE .. für ''(oder für jede Zeichenfolge, die nur aus Leerzeichen mit dem Datentyp besteht char(n))
NULL .. fürNULL
FALSE .. für alles andere
So überprüfen Sie: " stringexpressionist entweder NULL oder leer" :
(stringexpression = '') IS NOT FALSE
Oder der umgekehrte Ansatz (möglicherweise leichter zu lesen):
(stringexpression <> '') IS NOT TRUE
Funktioniert für jeden Zeichentyp einschließlich char(n). Das Handbuch zu Vergleichsoperatoren.
Oder verwenden Sie Ihren ursprünglichen Ausdruck ohne trim(), was für char(n)(siehe unten) kostspielig oder für andere Zeichentypen falsch ist: Zeichenfolgen, die nur aus Leerzeichen bestehen, werden als leere Zeichenfolge übergeben.
coalesce(stringexpression, '') = ''
Die Ausdrücke oben sind jedoch schneller.
Das Gegenteil zu behaupten ist noch einfacher: " stringexpressionist weder NULL noch leer" :
stringexpression <> ''
Hier geht es um den Datentyp char(n), kurz für : character(n). ( char/ characterstehen für char(1)/ character(1).) Von seiner Verwendung wird in Postgres abgeraten :
In den meisten Situationen textoder character varyingsollte stattdessen verwendet werden.
Nicht zu verwechseln char(n)mit anderen, nützlich, Charaktertypen varchar(n), varchar, textoder"char" (mit Anführungszeichen).
In char(n)einer leeren Zeichenfolge ist nicht anders als jede andere Zeichenfolge , die nur aus Leerzeichen. Alle diese sind gemäß Definition des Typs auf n Leerzeichen gefaltet char(n). Daraus folgt logischerweise, dass die obigen Ausdrücke auch funktionieren char(n)- genauso wie diese (was für andere Zeichentypen nicht funktionieren würde):
coalesce(stringexpression, ' ') = ' '
coalesce(stringexpression, '') = ' '
Demo
Eine leere Zeichenfolge entspricht einer beliebigen Zeichenfolge von Leerzeichen, wenn sie in Folgendes umgewandelt wird char(n):
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
Test auf "null oder leere Zeichenfolge" mit 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);
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
Test auf "null oder leere Zeichenfolge" mit 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);
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
Alte sqlfiddle
Verbunden:
charist aufgrund der Polsterung (und der daraus resultierenden Platzverschwendung) fast immer die falsche Wahl. Aber abgesehen davon: Ich glaube nicht, dass es eine bessere Lösung gibt.