Mysql NULL verursachte die Grube

Mysql NULL verursachte die Grube

Verwenden von NULL in Vergleichsoperatoren

mysql> wähle 1>NULL;
+--------+
| 1>NULL |
+--------+
| NULL |
+--------+
1 Zeile im Satz (0,00 Sek.)

mysql> wähle 1<NULL;
+--------+
| 1<NULL |
+--------+
| NULL |
+--------+
1 Zeile im Satz (0,00 Sek.)

mysql> wähle 1<>NULL;
+---------+
| 1<>NULL |
+---------+
| NULL |
+---------+
1 Zeile im Satz (0,00 Sek.)

mysql> wähle 1>NULL;
+--------+
| 1>NULL |
+--------+
| NULL |
+--------+
1 Zeile im Satz (0,00 Sek.)

mysql> wähle 1<NULL;
+--------+
| 1<NULL |
+--------+
| NULL |
+--------+
1 Zeile im Satz (0,00 Sek.)

mysql> Auswahl 1>=NULL;
+---------+
| 1>=NULL |
+---------+
| NULL |
+---------+
1 Zeile im Satz (0,00 Sek.)

mysql> wähle 1<=NULL;
+---------+
| 1<=NULL |
+---------+
| NULL |
+---------+
1 Zeile im Satz (0,00 Sek.)

mysql> wähle 1!=NULL;
+---------+
| 1!=NULL |
+---------+
| NULL |
+---------+
1 Zeile im Satz (0,00 Sek.)

mysql> wähle 1<>NULL;
+---------+
| 1<>NULL |
+---------+
| NULL |
+---------+
1 Zeile im Satz (0,00 Sek.)

mysql> wähle NULL=NULL,NULL!=NULL;
+-------------+---------+
| NULL=NULL | NULL!=NULL |
+-------------+---------+
| NULL | NULL |
+-------------+---------+
1 Zeile im Satz (0,00 Sek.)

mysql> wähle 1 in (null), 1 nicht in (null), null in (null), null nicht in (null);
+-------------+-----------------+----------------+--------------------+
| 1 in (null) | 1 nicht in (null) | null in (null) | null nicht in (null) |
+-------------+-----------------+----------------+--------------------+
| NULL | NULL | NULL | NULL |
+-------------+-----------------+----------------+--------------------+
1 Zeile im Satz (0,00 Sek.)

mysql> wähle 1=beliebig(wähle null),null=beliebig(wähle null);
+--------------------+-------------------------------------+
| 1=beliebig(null auswählen) | null=beliebig(null auswählen) |
+--------------------+-------------------------------------+
| NULL | NULL |
+--------------------+-------------------------------------+
1 Zeile im Satz (0,00 Sek.)

mysql> select 1=alle(select null),null=alle(select null);
+--------------------+-------------------------------------+
| 1=alle(null auswählen) | null=alle(null auswählen) |
+--------------------+-------------------------------------+
| NULL | NULL |
+--------------------+-------------------------------------+
1 Zeile im Satz (0,00 Sek.)

Fazit: Wenn ein beliebiger Wert mit den Operatoren (>, <, >=, <=, !=, <>) oder (in, not in, any/some, all) mit NULL verglichen wird, ist der Rückgabewert NULL. Wenn NULL als Boolescher Wert verwendet wird, ist es weder 1 noch 0.

Vorbereiten der Daten

mysql> Tabelle erstellen test1(a int,b int);
Abfrage OK, 0 Zeilen betroffen (0,01 Sek.)

mysql> in test1 Werte (1,1),(1,null),(null,null) einfügen;
Abfrage OK, 3 Zeilen betroffen (0,00 Sek.)
Datensätze: 3 Duplikate: 0 Warnungen: 0

mysql> wähle * aus test1;
+------+------+
| ein | b |
+------+------+
| 1 | 1 |
| 1 | NULL |
| NULL | NULL |
+------+------+
3 Zeilen im Satz (0,00 Sek.)

Schauen Sie sich die drei oben stehenden Daten genau an, insbesondere die NULL-Datensätze.

IN-, NOT IN- und NULL-Vergleiche

IN- und NULL-Vergleiche

mysql> wähle * aus test1;
+------+------+
| ein | b |
+------+------+
| 1 | 1 |
| 1 | NULL |
| NULL | NULL |
+------+------+
3 Zeilen im Satz (0,00 Sek.)

mysql> wähle * aus test1, wobei a in (null);
Leerer Satz (0,00 Sek.)

mysql> wähle * aus test1, wobei a in (null,1);
+------+------+
| ein | b |
+------+------+
| 1 | 1 |
| 1 | NULL |
+------+------+
2 Zeilen im Satz (0,00 Sek.)

Fazit: Beim Vergleich von IN mit NULL können Datensätze mit NULL nicht abgefragt werden.

NOT IN- und NULL-Vergleich

mysql> select * from test1, wobei ein nicht in (1);
Leerer Satz (0,00 Sek.)

mysql> select * from test1, wobei a nicht in (null);
Leerer Satz (0,00 Sek.)

mysql> select * from test1, wobei a nicht in (null,2);
Leerer Satz (0,00 Sek.)

mysql> select * from test1, wobei ein nicht in (2);
+------+------+
| ein | b |
+------+------+
| 1 | 1 |
| 1 | NULL |
+------+------+
2 Zeilen im Satz (0,00 Sek.)

Fazit: Wenn nach NOT IN ein NULL-Wert steht, ist das Abfrageergebnis des gesamten SQL in jeder Situation leer.

EXISTS-, NOT EXISTS- und NULL-Vergleiche

mysql> wähle * aus test2;
+------+------+
| ein | b |
+------+------+
| 1 | 1 |
| 1 | NULL |
| NULL | NULL |
+------+------+
3 Zeilen im Satz (0,00 Sek.)

mysql> wähle * von test1 t1, wo existiert (wähle * von test2 t2, wo t1.a = t2.a);
+------+------+
| ein | b |
+------+------+
| 1 | 1 |
| 1 | NULL |
+------+------+
2 Zeilen im Satz (0,00 Sek.)

mysql> select * from test1 t1, wo nicht vorhanden (select * from test2 t2, wo t1.a = t2.a);
+------+------+
| ein | b |
+------+------+
| NULL | NULL |
+------+------+
1 Zeile im Satz (0,00 Sek.)

Oben haben wir die Tabelle test1 kopiert und die Tabelle test2 erstellt.

Verwenden Sie exists und not exists in der Abfrageanweisung, um test1.a=test2.a zu vergleichen. Da = nicht mit NULL vergleichen kann, entspricht das Ergebnis den Erwartungen.

Um NULL zu beurteilen, können Sie nur IS NULL und IS NOT NULL verwenden

mysql> select 1 ist nicht null;
+-----------------+
| 1 ist nicht null |
+-----------------+
| 1 |
+-----------------+
1 Zeile im Satz (0,00 Sek.)

mysql> Auswahl 1 ist null;
+-------------+
| 1 ist null |
+-------------+
| 0 |
+-------------+
1 Zeile im Satz (0,00 Sek.)

mysql> Auswahl null ist null;
+--------------+
| null ist null |
+--------------+
| 1 |
+--------------+
1 Zeile im Satz (0,00 Sek.)

mysql> select null ist nicht null;
+------------------+
| null ist nicht null |
+------------------+
| 0 |
+------------------+
1 Zeile im Satz (0,00 Sek.)

Wenn man sich den obigen Effekt ansieht, ist das zurückgegebene Ergebnis 1 oder 0.

Fazit: IS NULL und IS NOT NULL können nur verwendet werden, um zu bestimmen, ob ein Wert leer ist.

Die NULL-Tücke in Aggregatfunktionen

Beispiel

mysql> wähle Anzahl(a), Anzahl(b), Anzahl(*) aus Test1;
+----------+----------+----------+
| Anzahl(a) | Anzahl(b) | Anzahl(*) |
+----------+----------+----------+
| 2 | 1 | 3 |
+----------+----------+----------+
1 Zeile im Satz (0,00 Sek.)
  • count(a) gibt 2 Zeilen zurück, aber die Zeilen mit NULL im Feld a werden nicht gezählt.
  • count(b) gibt 1 Datensatzzeile zurück, und die 2 Datensatzzeilen mit NULL-Werten werden nicht gezählt.
  • count(*) kann alle Daten zählen, unabhängig davon, ob die Daten im Feld NULL sind.

Weiter beobachten

mysql> select * from test1, wobei a null ist;
+------+------+
| ein | b |
+------+------+
| NULL | NULL |
+------+------+
1 Zeile im Satz (0,00 Sek.)

mysql> wähle count(a) aus test1, wobei a null ist;
+----------+
| Anzahl(a) |
+----------+
| 0 |
+----------+
1 Zeile im Satz (0,00 Sek.)

Das erste SQL oben verwendet „null“, um das Ergebnis abzufragen, und count(a) im zweiten SQL gibt 0 Zeilen zurück.

Fazit: count(field) kann den Wert des Felds nicht zählen, der NULL ist, aber count(*) kann die Zeilen zählen, deren Wert null ist.

NULL kann nicht als Primärschlüsselwert verwendet werden

mysql> Tabelle erstellen test3(a int Primärschlüssel, b int);
Abfrage OK, 0 Zeilen betroffen (0,01 Sek.)

mysql> in Test3-Werte einfügen (null, 1);
FEHLER 1048 (23000): Spalte „a“ kann nicht null sein

Wir haben oben eine Tabelle test3 erstellt. Feld a ist nicht angegeben und kann nicht leer sein. Es werden NULL-Daten eingefügt. Der Fehlergrund ist: Der Wert von Feld a kann nicht NULL sein. Werfen wir einen Blick auf die Anweisung zur Tabellenerstellung:

mysql> anzeigen, Tabelle erstellen, test3;
+----------+---------+
| Tabelle | Tabelle erstellen |
+-------+------------+
| test3 | TABELLE ERSTELLEN `test3` (
 `a` int(11) NICHT NULL,
 `b` int(11) DEFAULT NULL,
 PRIMÄRSCHLÜSSEL (`a`)
) ENGINE=InnoDB STANDARD-CHARSET=utf8
+-------+------------+
1 Zeile im Satz (0,00 Sek.)

Wie aus dem obigen Skript ersichtlich, wird ein Feld automatisch auf ungleich null gesetzt, wenn es sich um einen Primärschlüssel handelt.

Fazit: Wenn ein Feld ein Primärschlüssel ist, wird es automatisch auf ungleich null gesetzt.

Nachdem ich das alles gelesen habe, bin ich immer noch ein wenig verwirrt. Die NULL-Situation ist in der Tat schwierig zu handhaben und fehleranfällig. Der effektivste Weg besteht darin, die Verwendung von NULL zu vermeiden. Daher wird dringend empfohlen, beim Erstellen eines Felds darauf zu achten, dass das Feld keinen NULL-Wert zulässt und ein Standardwert festgelegt wird.

Zusammenfassen

  • NULL ist ein Boolescher Wert, der weder 1 noch 0 ist.
  • Alle Werte und NULL verwenden Operatoren (>, <, >=, <=, !=, <>) oder (in, nicht in, beliebig/einige, alle), der Rückgabewert ist NULL
  • Beim Vergleich von IN mit NULL können Datensätze mit NULL nicht abgefragt werden.
  • Wenn nach NOT IN ein NULL-Wert steht, ist das Abfrageergebnis der gesamten SQL-Anweisung in jedem Fall leer.
  • Um festzustellen, ob es leer ist, können Sie nur IS NULL und IS NOT NULL verwenden
  • count(field) kann den Wert des Felds, der NULL ist, nicht zählen, aber count(*) kann die Zeilen mit Nullwerten zählen.
  • Wenn ein Feld der Primärschlüssel ist, wird das Feld automatisch auf ungleich null gesetzt.
  • Die Fallstricke, die durch NULL verursacht werden, sind schwer zu vermeiden. Es wird dringend empfohlen, beim Erstellen eines Felds kein NULL zuzulassen und einen Standardwert anzugeben

Dies ist das Ende dieses Artikels über die Fallstricke, die durch MySQL NULL verursacht werden. Weitere relevante Inhalte zu den Fallstricken, die durch MySQL NULL verursacht werden, finden Sie in früheren Artikeln auf 123WORDPRESS.COM oder in den folgenden verwandten Artikeln. Ich hoffe, Sie werden 123WORDPRESS.COM auch in Zukunft unterstützen!

Das könnte Sie auch interessieren:
  • Warum sollten MySQL-Felder NOT NULL verwenden?
  • Ein kleines Problem mit Nullwerten in MySQL
  • Einige häufige Fehler mit MySQL null
  • Detaillierte Erklärung des Unterschieds zwischen MySQL null und nicht null und null und leerem Wert''''''''
  • Lösung für das MySQL IFNULL-Beurteilungsproblem
  • Unterscheiden Sie zwischen Nullwert und leerem Zeichen ('''') in MySQL
  • Detaillierte Erklärung zum Schreiben von MySQL ungleich null und gleich null
  • Zusammenfassung der Wissenspunkte im Zusammenhang mit Null (IFNULL, COALESCE und NULLIF) in MySQL
  • Detaillierte Erklärung der MySQL-Dreiwertelogik und NULL

<<:  Analyse der Implementierungsschritte für die Docker-Containerverbindung

>>:  Sechs Möglichkeiten, die Größe von Docker-Images zu reduzieren

Artikel empfehlen

Detaillierte Erläuterung der allgemeinen Schritte zur SQL-Anweisungsoptimierung

Vorwort In diesem Artikel erfahren Sie hauptsächl...

W3C Tutorial (4): W3C XHTML Aktivitäten

HTML ist eine Hybridsprache, die zum Veröffentlic...

Tutorial zur Installation und Konfiguration der Linux CentOS MySQL-Datenbank

Hinweise zur Installation der MySQL-Datenbank, mi...

Optimierung des MySQL Thread_Stack-Verbindungsthreads

MySQL kann nicht nur über das Netzwerk, sondern a...

Methoden für JavaScript-String-Objekte

Inhaltsverzeichnis Methoden des String-Objekts Me...

Axios Sekundärkapselungsbeispiel Demo im Projekt

1. Warum verpacken? Erleichtert das Aufrufen von ...

Eine kurze Diskussion über mehrere aufgetretene Browserkompatibilitätsprobleme

Hintergrund Das Lösen von Browserkompatibilitätsp...

Einige kleine Methoden, die häufig in HTML-Seiten verwendet werden

Fügen Sie das Tag <Head> hinzu <meta http...

W3C Tutorial (5): W3C XML Aktivitäten

XML dient der Beschreibung, Speicherung, Übertrag...

So erstellen Sie einen MySQL PXC-Cluster

Inhaltsverzeichnis 1. Einführung in PXC 1.1 Einfü...

Beheben von Problemen beim Importieren und Exportieren von Mysql

Hintergrund Da ich alle meine Aufgaben auf Docker...

Erstellen Sie ein Docker-Image mit Dockerfile

Inhaltsverzeichnis Erstellen Sie ein Docker-Image...