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

mysql5.7.18 dekomprimierte Version zum Starten des MySQL-Dienstes

Die dekomprimierte Version von mysql5.7.18 starte...

Ausführliche Erklärung dieses Schlüsselworts in JavaScript

Inhaltsverzeichnis 1. Einleitung 2. Verstehen Sie...

Detaillierte Einführung in den DOCTYPE-Typ

<br />Wir deklarieren DOCTYPE in HTML normal...

Detaillierte Erklärung zur Verwendung von MySQL, wobei

Inhaltsverzeichnis 1. Einleitung 2. Haupttext 2.1...

Beispiel für das Hinzufügen von Attributen mithilfe von Stilen in HTML

Fügen Sie den erforderlichen Links Inline-Stile hi...

JavaScript-HTML zur Implementierung der mobilen Red Envelope Rain-Funktionsseite

In diesem Artikelbeispiel wird der spezifische HT...

Einige weniger bekannte Sortiermethoden in MySQL

Vorwort ORDER BY 字段名升序/降序. Ich glaube, jeder hier...

Beispiel für eine adaptive CSS-Bildschirmgrößenimplementierung

Um eine CSS-Bildschirmgrößenanpassung zu erreiche...

Idea stellt Remote-Docker bereit und konfiguriert die Datei

1. Ändern Sie die Docker-Konfigurationsdatei des ...

Zusammenfassung der Binlog-Nutzung der MySQL-Datenbank (unbedingt lesen)

Ich werde nicht näher darauf eingehen, wie wichti...

So mounten Sie eine neue Festplatte auf einem Linux-Cloud-Server

Hintergrund Im Unternehmen wurde ein neuer Server...