Analyse der Fallstricke beim Rundungsvorgang der ROUND-Funktion in MySQL

Dieser Artikel veranschaulicht anhand von Beispielen die Tücken von Rundungsoperationen mit der ROUND-Funktion in MySQL. Teilen Sie uns die Einzelheiten zu Ihrer Information mit:

In MySQL wird ROUND zum Runden von Abfrageergebnissen verwendet. Ich habe jedoch kürzlich festgestellt, dass die Ergebnisse mit ROUND nicht wie erwartet gerundet wurden. In diesem Artikel wird dieses Problem beschrieben, um zu verhindern, dass andere den gleichen Fehler machen wie ich.

Problembeschreibung

Angenommen, wir haben einen Datentabellentest. Die Anweisung zur Tabellenerstellung lautet wie folgt

CREATE TABLE-Test (
 id int(11) NICHT NULL AUTO_INCREMENT,
 Feld1 bigint(10) DEFAULT NULL,
 Feld2 Dezimalzahl (10,0) DEFAULT NULL,
 Feld3 int(10) DEFAULT NULL,
 Feld4 float(15,4) DEFAULT NULL,
 Feld5 float(15,4) DEFAULT NULL,
 Feld6 float(15,4) DEFAULT NULL,
 PRIMÄRSCHLÜSSEL (id)
)ENGINE=InnoDB STANDARD-CHARSET=utf8;

Wir haben eine Tabelle mit dem Namen „Test“ erstellt, die neben dem ID-Feld mehrere Felder mit unterschiedlichen Datentypen enthält. Lassen Sie uns einen Datensatz in diese Tabelle einfügen.

INSERT INTO Test (Feld1, Feld2, Feld3, Feld4, Feld5, Feld6) WERT (100, 100, 100, 1,005, 3,5, 2,5);

Nach dem Einfügen sehen die Daten in der Tabelle so aus

mysql> wähle * aus Test;
+----+--------+--------+--------+--------+--------+--------+
| ID | Feld1 | Feld2 | Feld3 | Feld4 | Feld5 | Feld6 |
+----+--------+--------+--------+--------+--------+--------+
| 1 | 100 | 100 | 100 | 1,0050 | 3,5000 | 2,5000 |
+----+--------+--------+--------+--------+--------+--------+
1 Zeile im Satz (0,00 Sek.)

Wenn wir jetzt das folgende SQL ausführen, was wird Ihrer Meinung nach das Ergebnis sein?

WÄHLEN
 Runde(Feld1 * Feld4),
 Runde(Feld2 * Feld4),
 Runde(Feld3 * Feld4),
 Runde(Feld1 * 1,005),
 Runde (Feld2 * 1,005),
 Runde (Feld3 * 1,005),
 Runde (Feld5),
 Runde (Feld6)
VON Test;

Zuerst dachte ich, das Ergebnis wäre 101, da die sechs Werte oben alle auf 100 * 1,005 gerundet sind, also muss das Ergebnis 101 sein und die letzten beiden müssen 4 und 3 sein. Das Endergebnis weicht jedoch stark von meinen Erwartungen ab.

*************************** 1. Reihe ***************************
Runde (Feld1 * Feld4): 100
Runde (Feld2 * Feld4): 100
Runde (Feld3 * Feld4): 100
 Runde (Feld1 * 1,005): 101
 Runde (Feld2 * 1,005): 101
 Runde (Feld3 * 1,005): 101
    Runde (Feld5): 4
    Runde (Feld6): 2
1 Zeile im Satz (0,00 Sek.)

Warum passiert das?

Es ist dasselbe 100*1,005. Warum ist das Ergebnis, das durch die Multiplikation der Felder in der Datenbank erzielt wird, ein anderes als das Ergebnis, das durch die direkte Multiplikation des Felds mit der Dezimalzahl erzielt wird?

Ich habe keine Ahnung, wie ich dieses Problem lösen soll, und ich habe Baidu und Google durchsucht, aber ohne Erfolg. . . Es gibt keine andere Möglichkeit, als mich auf mich selbst zu verlassen. Das Nützlichste zu diesem Zeitpunkt ist die offizielle Website-Dokumentation. Also habe ich die offizielle MySQL-Dokumentation zur ROUND-Funktion durchsucht, die die folgenden beiden Regeln enthält:

• Für Zahlen mit genauen Werten verwendet ROUND() die Regel „Auf die Hälfte aufrunden“ .
• Bei Zahlen mit Näherungswerten hängt das Ergebnis von der C-Bibliothek ab. Auf vielen Systemen bedeutet dies, dass ROUND() die Regel „Auf nächste gerade Zahl runden “ verwendet: Ein Wert mit einem beliebigen Bruchteil wird auf die nächste gerade Zahl ROUND . (Bei Näherungswerten hängt es von der zugrunde liegenden C-Funktionsbibliothek ab. Auf vielen Systemen verwendet die Funktion ROUND() die Regel „Auf nächste gerade Zahl runden“)

Aus diesen beiden Regeln können wir ersehen, dass beim Multiplizieren zweier Felder das Endergebnis gemäß dem Float -Typ verarbeitet wird und der Float -Typ im Computer keine exakte Zahl ist, sodass das Verarbeitungsergebnis gemäß der zweiten Regel verarbeitet wird. Das Ergebnis des direkten Integer-Felds und der Dezimaloperation wie 1,005 liegt daran, dass die beiden an der Operation beteiligten Werte exakte Zahlen sind, sodass es gemäß der ersten Regel berechnet wird. Anhand der Ergebnisse der Ausführung ROUND auf Feld5 und Feld6 lässt sich deutlich erkennen, dass diese tatsächlich in die nächste gerade Zahl umgewandelt werden.

Zusammenfassen

Anhand dieses Beispiels können wir erkennen, dass wir bei der Verwendung von ROUND in MySQL sehr vorsichtig sein müssen. Insbesondere wenn die an der Berechnung beteiligten Felder Gleitkommazahlen enthalten, sind die Berechnungsergebnisse ungenau.

Leser, die an weiteren MySQL-bezogenen Inhalten interessiert sind, können sich die folgenden Themen auf dieser Site ansehen: „MySQL-Abfragekenntnisse“, „MySQL-Transaktionsoperationskenntnisse“, „MySQL-gespeicherte Prozedurkenntnisse“, „Zusammenfassung der Kenntnisse zu MySQL-Datenbanksperren“ und „Zusammenfassung der allgemeinen MySQL-Funktionen“.

Ich hoffe, dass dieser Artikel für jedermann beim Entwurf einer MySQL-Datenbank hilfreich ist.