1. Arithmetische Operatoren
Es können allgemeine arithmetische Operatoren verwendet werden. Beachten Sie, dass für - und * die Genauigkeit des Berechnungsergebnisses BIGINT (64 Bit) beträgt. Wenn ein Parameter eine vorzeichenlose Ganzzahl ist und die anderen Parameter ebenfalls Ganzzahlen sind, ist das Ergebnis eine vorzeichenlose Ganzzahl.
Plus:
MYSQL> SELECT 3 5;
-> 8
Minus Zeichen:
mysql> SELECT 3-5;
-> -2
-
Ein Dollar Minuszeichen. Ersetzen Sie Parametersymbole.
mysql> SELECT - 2;
-> -2
Hinweis: Wenn der Operator gleichzeitig mit demselben BIGINT verwendet wird, ist der Rückgabewert ebenfalls ein BIGINT. Dies bedeutet, dass Sie versuchen sollten, die Verwendung von – mit Ganzzahlen zu vermeiden, da dies zu –263 führen könnte.
*
Vorzeichen multiplizieren:
SELECT 3*5;
-> 15
MYSQL> 18014398509481984.0;
-> 324518553658426726783156020576256.0
MYSQL> SELECT 18014398509481984*180143 985 09481984;
-> 0
Das Ergebnis des letzten Ausdrucks ist falsch von. Der Grund dafür ist, dass das Ergebnis der Ganzzahlmultiplikation den 64-Bit-Bereich der BIGINT-Berechnungen überschreitet.
/
Divisionszeichen:
mysql> SELECT 3/5;
-> 0,60
Das Ergebnis der Division durch Null Für NULL:
mysql> SELECT 102/(1-1);
->NULL
Nur wenn der Ausführungskontext konvertiert werden soll Die Division wird mit dem BIGINT-Algorithmus nur verwendet, wenn es sich um eine Ganzzahl handelt.
DIV
Ganzzahldivision. Ähnlich wie FLOOR(), jedoch ist die Verwendung des BIGINT-Algorithmus ebenfalls zuverlässig.
mysql> SELECT 5 DIV 2;
-> 2
Mathematische Funktionen
Wenn ein Fehler auftritt, geben alle mathematischen Funktionen NULL zurück .
ABS(X)
Gibt den absoluten Wert von X zurück.
mysql> SELECT ABS(2);
-> 2
SELECT ABS(-32);
-> 🎜>
Diese Funktion unterstützt die Verwendung von BIGINT-Werten.
ACOS(X)
Gibt den Umkehrkosinus von X zurück, d. h. der Kosinus ist der Wert von X. Wenn X nicht im Bereich von -1 bis 1 liegt, wird NULL zurückgegeben.
mysql> SELECT ACOS(1);
-> 0
SELECT ACOS(1.0001);
-> >
mysql> SELECT ACOS(0);
-> 1.5707963267949
ASIN(X)
Gibt den Umkehrsinus des Werts zurück. Wenn X Wenn X nicht im Bereich von -1 bis 1 liegt, wird NULL zurückgegeben.
ATAN(X)
mysql> SELECT ASIN(0.2); -> 0.20135792079033
mysql> SELECT ASIN('foo');
+-------------+
| ASIN('foo') |
+-------------+
| 0 |
+-------------+
1 row in set, 1 warning (0.00 sec)
mysql> SHOW WARNINGS;
+---------+------+-----------------------------------------+
| Level | Code | Message |
+---------+------+-----------------------------------------+
| Warning | 1292 | Truncated incorrect DOUBLE value: 'foo' |
+---------+------+-----------------------------------------+
Nach dem Login kopieren
ATAN(X)
Gibt den Arcustangens des Werts zurück.
mysql> SELECT ATAN(2);
-> 1.1071487177941
mysql> 7941
ATAN(Y,X), X)
Gibt den Arcustangens zweier Variablen X und Y zurück. Sie ähnelt der Arkustangensberechnung von Y oder X, außer dass die Vorzeichen beider Parameter zur Bestimmung des Quadranten des Ergebnisses verwendet werden.
mysql> SELECT ATAN(-2,2);
-> -0.78539816339745
mysql> SELECT ATAN2(PI(),0);
-> 1,5707963267949
CEILING(X) CEIL(X)
Gibt den kleinsten ganzzahligen Wert zurück, der nicht kleiner als X ist.
MYSQL> SELECT CEILING(1.23);
->
Diese beiden Funktionen haben die gleiche Bedeutung. Beachten Sie, dass der Rückgabewert in einen BIGINT umgewandelt wird.
COS(X)
Gibt den Kosinus von X zurück, wobei X im Bogenmaß angegeben wird.
mysql> SELECT COS(PI());
-> -1
COT(X)
Gibt den Kotangens von X zurück.
MySQL> SELECT COT(12);
-> -1.5726734063977
MySQL> 🎜>
Berechnen Sie die Prüfwert des zyklischen Redundanzcodes und Rückgabe eines 32-Bit-Werts ohne Vorzeichen. Wenn der Parameter NULL ist, ist das Ergebnis NULL. Das Argument sollte eine Zeichenfolge sein und wird (sofern möglich) als solche behandelt, wenn es sich nicht um eine Zeichenfolge handelt.
MySQL> SELECT CRC32('MySQL');
-> 3259397556
MySQL> SELECT CRC32('MySQL');
-> ; 2501908538
DEGREES(X)
Rückgabeparameter X, der vom Bogenmaß in Grad umgerechnet wird.
mysql> SELECT DEGREES(PI());
-> 180
SELECT DEGREES(PI() / 2);
-> 90
EXP(X)
Gibt den Wert von e hoch mit X (der Basis des natürlichen Logarithmus) zurück.
mysql> SELECT EXP(2);
-> 7.3890560989307
mysql> SELECT EXP(-2);
-> 🎜>
mysql> SELECT EXP(0);
-> 1
FLOOR(X)
Gibt den größten ganzzahligen Wert zurück, der nicht größer als X ist.
MYSQL> SELECT FLOOR(1.23);
-> 1
SELECT FLOOR(-1.23);
-2
Beachten Sie, dass der Rückgabewert in einen BIGINT umgewandelt wird.
FORMAT(X,D)
Schreiben Sie die Zahl. Bits werden beibehalten, gerundet und das Ergebnis wird als Zeichenfolge zurückgegeben.
LN(X)
Gibt den natürlichen Logarithmus von X zurück, d. h. den Logarithmus von X relativ zur Basis e.
mysql> SELECT LN(2);
-> 0.69314718055995
MYSql> 🎜>
Diese Funktion hat die gleiche Bedeutung wie LOG(X).
LOG(X) LOG(B,X)
Wenn diese Funktion mit einem Parameter aufgerufen wird, gibt sie den natürlichen Logarithmus von X zurück.
mysql>
-> 0.69314718055995
mysql> 🎜>
Wenn diese Funktion mit zwei Parametern aufgerufen wird, gibt sie den Logarithmus von X für jede Basis B zurück.
mysql> SELECT LOG(2,65536);
-> 16
MYSql>
LOG(B,X) entspricht LOG(X) / LOG(B).
LOG2(X)
Gibt den Logarithmus zur Basis 2 von X zurück.
mysql> SELECT LOG2(65536);
-> 16
SELECT LOG2(-100);
-> 🎜>
LOG2() ist sehr effektiv, um herauszufinden, wie viele Bits zum Speichern einer Zahl benötigt werden. Diese Funktion entspricht dem Ausdruck LOG(X) / LOG(2).
LOG10(X)
Gibt den Logarithmus zur Basis 10 von X zurück.
MySQL> SELECT LOG10(2);
-> >
mysql> SELECT LOG10(-100);
->NULL
LOG10(X) entspricht LOG(10,X).
MOD(N,M) , N % M N MOD M
Modulbetrieb. Gibt den Rest nach der Division von N durch M zurück.
mysql> SELECT MOD(234, 10);
-> 4
SELECT 253 % 7;
-> 🎜>
mysql> SELECT MOD(29,9);
-> 2
MYSql> SELECT 29 MOD 9;
-> >
Diese Funktion unterstützt die Verwendung von BIGINT-Werten.
MOD() funktioniert auch für Werte mit Dezimalteilen, es gibt den genauen Rest nach der Division zurück:
mysql>
- > 1,5
PI()
Gibt den Wert von ϖ (pi) zurück. Die standardmäßige Dezimalstelle für die Anzeige ist 7, MySQL verwendet jedoch intern Werte mit voller doppelter Genauigkeit.
mysql> SELECT PI();
-> 3.141593
MYSql> 3.141592653589793116
POW(X,Y) , POWER(X,Y)
Gibt den Ergebniswert von X, erhöht auf die Y-Potenz, zurück.
mysql> SELECT POW(2,2);
-> 4
SELECT POW(2,-2);
- > 0,25
RADIANS(X)
Gibt den Parameter X zurück, konvertiert von Grad in Bogenmaß (beachten Sie, dass ϖ Bogenmaß 180 Grad entspricht).
mysql> SELECT RADIANS(90);
-> 1.5707963267949
RAND() RAND(N)
Gibt einen zufälligen Gleitkommawert v zurück , der Bereich liegt zwischen 0 und 1 (d. h. der Bereich ist 0 ≤ v ≤ 1,0). Wenn ein ganzzahliger Parameter N angegeben wird, wird er als Startwert zum Generieren der Wiederholungssequenz verwendet.
mysql> SELECT RAND();
-> 0.9233482386203
mysql> SELECT RAND(20);
-> 0.1588826125 1047
mysql> SELECT RAND();
-> ; 0,70100469486881
mysql> Wenn Sie i ≤ R ≤ j möchten, müssen Sie den Ausdruck FLOOR(i RAND() * (j – i 1) verwenden. ). Um beispielsweise eine zufällige Ganzzahl im Bereich von 7 bis 12 (einschließlich) zu erhalten, können Sie die folgende Anweisung verwenden:
SELECT FLOOR(7 (RAND() * 6));
In der ORDER BY-Anweisung können Sie keine Spalte mit einem RAND()-Wert verwenden, da ORDER BY die Vielfachen der Spalte berechnet. Die Datenzeilen können jedoch wie folgt in zufälliger Reihenfolge abgerufen werden:
mysql> SELECT * FROM tbl_name ORDER BY RAND();
ORDER BY RAND() kombiniert mit LIMIT aus einer Reihe von Spalten Es ist nützlich, eine Zufallsstichprobe auszuwählen:
mysql> SELECT * FROM table1, table2 WHERE a=b AND c-> ORDER BY RAND() LIMIT 1000;
Beachten Sie, dass in der WHERE-Anweisung RAND() jedes Mal neu berechnet wird, wenn WHERE ausgeführt wird.
RAND() soll kein exakter Zufallsgenerator sein, sondern vielmehr eine schnelle Möglichkeit, bewegliche Ad-hoc-Zufallszahlen zwischen Plattformen mit derselben MySQL-Version zu generieren.
ROUND(X) ROUND(X,D)
返回参数X, 其值接近于最近似的整数。在有两个参数的情况下，返回 X ，其值保留到小数点后D位，而第D位的保留方式为四舍五入。若要接保留X值小数点左边的D 位，可将 D 设为负值。
mysql> SELECT ROUND(-1.23);
-> -1
mysql> SELECT ROUND(-1.58);
-> -2
mysql> SELECT ROUND(1.58);
-> 2
mysql> SELECT ROUND(1.298, 1);
-> 1.3
mysql> SELECT ROUND(1.298, 0);
-> 1
mysql> SELECT ROUND(23.298, -1);
-> 20
返回值的类型同 第一个自变量相同(假设它是一个整数、双精度数或小数)。这意味着对于一个整数参数,结果也是一个整数(无小数部分)。
当第一个参数是十进制常数时，对于准确值参数，ROUND() 使用精密数学题库：
对于准确值数字, ROUND() 使用“四舍五入” 或“舍入成最接近的数” 的规则:对于一个分数部分为 .5或大于 .5的值，正数则上舍入到邻近的整数值， 负数则下舍入临近的整数值。(换言之, 其舍入的方向是数轴上远离零的方向）。对于一个分数部分小于.5 的值，正数则下舍入下一个整数值，负数则下舍入邻近的整数值，而正数则上舍入邻近的整数值。
对于近似值数字，其结果根据C 库而定。在很多系统中，这意味着 ROUND()的使用遵循“舍入成最接近的偶数”的规则： 一个带有任何小数部分的值会被舍入成最接近的偶数整数。
以下举例说明舍入法对于精确值和近似值的不同之处：
mysql> SELECT ROUND(2.5), ROUND(25E-1);
+------------+--------------+
| ROUND(2.5) | ROUND(25E-1) |
+------------+--------------+
| 3 | 2 |
+------------+--------------+
Nach dem Login kopieren
SIGN(X)
返回参数作为-1、 0或1的符号，该符号取决于X 的值为负、零或正。
mysql> SELECT SIGN(-32);
-> -1
mysql> SELECT SIGN(0);
-> 0
mysql> SELECT SIGN(234);
-> 1
SIN(X)
返回X 正弦，其中 X 在弧度中被给定。
mysql> SELECT SIN(PI());
-> 1.2246063538224e-16
mysql> SELECT ROUND(SIN(PI()));
-> 0
SQRT(X)
返回非负数X 的二次方根。
mysql> SELECT SQRT(4);
-> 2
mysql> SELECT SQRT(20);
-> 4.4721359549996
mysql> SELECT SQRT(-16);
-> NULL
TAN(X)
返回X 的正切，其中X 在弧度中被给定。
mysql> SELECT TAN(PI());
-> -1.2246063538224e-16
mysql> SELECT TAN(PI()+1);
-> 1.5574077246549
TRUNCATE(X,D)
返回被舍去至小数点后D位的数字X。若D 的值为 0, 则结果不带有小数点或不带有小数部分。可以将D设为负数,若要截去(归零) X小数点左起第D位开始后面所有低位的值.
mysql> SELECT TRUNCATE(1.223,1);
-> 1.2
mysql> SELECT TRUNCATE(1.999,1);
-> 1.9
mysql> SELECT TRUNCATE(1.999,0);
-> 1
mysql> SELECT TRUNCATE(-1.999,1);
-> -1.9
mysql> SELECT TRUNCATE(122,-2);
-> 100
mysql> SELECT TRUNCATE(10.28*100,0);
-> 1028
所有数字的舍入方向都接近于零。
