14.6.2 Mathematical Functions — MySQL 8.4

14.6.2 Математические функции

Таблица 14.10 Математические функции

Таблица 14.10 Математические функции
Имя	Описание
`ABS()`	Возвращает абсолютное значение
`ACOS()`	Возвращает обратный косинус
`ASIN()`	Возвращает обратный синус
`ATAN()`	Возвращает обратную тангенс
`ATAN2()`, `ATAN()`	Возвращает обратную тангенс от двух аргументов
`CEIL()`	Возвращает наименьшее целое число, не меньшее, чем аргумент
`CEILING()`	Возвращает наименьшее целое число, не меньшее, чем аргумент
`CONV()`	Преобразует числа между различными системами счисления
`COS()`	Возвращает косинус
`COT()`	Возвращает котангенс
`CRC32()`	Вычисляет значение контрольной суммы циклического избыточного кода
`DEGREES()`	Преобразует радиан в градусы
`EXP()`	Возводит в степень
`FLOOR()`	Возвращает наибольшее целое число, не большее, чем аргумент
`LN()`	Возвращает натуральный логарифм аргумента
`LOG()`	Возвращает натуральный логарифм первого аргумента
`LOG10()`	Возвращает логарифм по основанию 10 аргумента
`LOG2()`	Возвращает логарифм по основанию 2 аргумента
`MOD()`	Возвращает остаток
`PI()`	Возвращает значение числа пи
`POW()`	Возвращает аргумент, возведенный в указанную степень
`POWER()`	Возвращает аргумент, возведенный в указанную степень
`RADIANS()`	Возвращает аргумент, преобразованный в радианы
`RAND()`	Возвращает случайное значение с плавающей точкой
`ROUND()`	Округляет аргумент
`SIGN()`	Возвращает знак аргумента
`SIN()`	Возвращает синус аргумента
`SQRT()`	Возвращает квадратный корень из аргумента
`TAN()`	Возвращает тангенс аргумента
`TRUNCATE()`	Отбрасывает десятичные знаки до указанного количества

Во всех математических функциях в случае ошибки возвращается NULL.

ABS(X)

Возвращает абсолютное значение X, или NULL, если X является NULL.

Тип результата выводится из типа аргумента. Следствием этого является то, что ABS(-9223372036854775808) генерирует ошибку, поскольку результат не может быть сохранен в знаковом значении BIGINT.
```
mysql> SELECT ABS(2);
        -> 2
mysql> SELECT ABS(-32);
        -> 32
```
Эта функция безопасна для использования со значениями BIGINT.
ACOS(X)

Возвращает арккосинус X, то есть значение, косинус которого равен X. Возвращает NULL, если X не находится в диапазоне от -1 до 1, или если X является NULL.
```
mysql> SELECT ACOS(1);
        -> 0
mysql> SELECT ACOS(1.0001);
        -> NULL
mysql> SELECT ACOS(0);
        -> 1.5707963267949
```

ASIN(X)

Возвращает арксинус X, то есть значение, синус которого равен X. Возвращает NULL, если X не находится в диапазоне от -1 до 1, или если X является NULL.

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' |
+---------+------+-----------------------------------------+

ATAN(X)

Возвращает арктангенс X, то есть значение, тангенс которого равен X. Возвращает NULL, если X является NULL
```
mysql> SELECT ATAN(2);
        -> 1.1071487177941
mysql> SELECT ATAN(-2);
        -> -1.1071487177941
```
ATAN(Y,X), ATAN2(Y,X)

Возвращает арктангенс двух переменных X и Y. Это аналогично вычислению арктангенса Y / X, за исключением того, что знаки обоих аргументов используются для определения квадранта результата. Возвращает NULL, если X или Y является NULL.
```
mysql> SELECT ATAN(-2,2);
        -> -0.78539816339745
mysql> SELECT ATAN2(PI(),0);
        -> 1.5707963267949
```
CEIL(X)

CEIL() является синонимом для CEILING().
CEILING(X)

Возвращает наименьшее целое значение, не меньшее, чем X. Возвращает NULL, если X является NULL.
```
mysql> SELECT CEILING(1.23);
        -> 2
mysql> SELECT CEILING(-1.23);
        -> -1
```
Для числовых аргументов с точным значением возвращаемое значение имеет числовой тип с точным значением. Для строковых или вещественных аргументов возвращаемое значение имеет тип с плавающей точкой.
CONV(N,from_base,to_base)

Преобразует числа между различными системами счисления. Возвращает строковое представление числа N, преобразованного из системы счисления from_base в систему счисления to_base. Возвращает NULL, если любой аргумент является NULL. Аргумент N интерпретируется как целое число, но может быть указан как целое число или строка. Минимальное основание равно 2, а максимальное — 36. Если from_base является отрицательным числом, N рассматривается как знаковое число. В противном случае N обрабатывается как беззнаковое. CONV() работает с 64-битной точностью.

CONV() возвращает NULL, если любой из его аргументов является NULL.
```
mysql> SELECT CONV('a',16,2);
        -> '1010'
mysql> SELECT CONV('6E',18,8);
        -> '172'
mysql> SELECT CONV(-17,10,-18);
        -> '-H'
mysql> SELECT CONV(10+'10'+'10'+X'0a',10,10);
        -> '40'
```
COS(X)

Возвращает косинус X, где X задан в радианах. Возвращает NULL, если X является NULL.
```
mysql> SELECT COS(PI());
        -> -1
```

COT(X)

Возвращает котангенс X. Возвращает NULL, если X является NULL.

mysql> SELECT COT(12);
        -> -1.5726734063977
mysql> SELECT COT(0);
        -> out-of-range error

CRC32(expr)

Вычисляет значение циклического избыточного кода и возвращает 32-битное беззнаковое значение. Результат равен NULL, если аргумент является NULL. Ожидается, что аргумент будет строкой, и (если возможно) он обрабатывается как строка, если это не так.
```
mysql> SELECT CRC32('MySQL');
        -> 3259397556
mysql> SELECT CRC32('mysql');
        -> 2501908538
```
DEGREES(X)

Возвращает аргумент X, преобразованный из радианов в градусы. Возвращает NULL, если X является NULL.
```
mysql> SELECT DEGREES(PI());
        -> 180
mysql> SELECT DEGREES(PI() / 2);
        -> 90
```
EXP(X)

Возвращает значение e (основание натуральных логарифмов), возведенное в степень X. Обратной функцией является LOG() (используя только один аргумент) или LN().

Если X является NULL, эта функция возвращает NULL.
```
mysql> SELECT EXP(2);
        -> 7.3890560989307
mysql> SELECT EXP(-2);
        -> 0.13533528323661
mysql> SELECT EXP(0);
        -> 1
```
FLOOR(X)

Возвращает наибольшее целое значение, не большее, чем X. Возвращает NULL, если X является NULL.
```
mysql> SELECT FLOOR(1.23), FLOOR(-1.23);
        -> 1, -2
```
Для числовых аргументов с точным значением возвращаемое значение имеет числовой тип с точным значением. Для строковых или вещественных аргументов возвращаемое значение имеет тип с плавающей точкой.
FORMAT(X,D)

Форматирует число X в формат, подобный '#,###,###.##', округленное до D десятичных знаков, и возвращает результат в виде строки. Подробнее см. Раздел 14.8, «Строковые функции и операторы».
HEX(N_or_S)

Эта функция может использоваться для получения шестнадцатеричного представления десятичного числа или строки; способ, которым она это делает, варьируется в зависимости от типа аргумента. Подробности см. в описании этой функции в Разделе 14.8, «Строковые функции и операторы».
LN(X)

Возвращает натуральный логарифм X; то есть логарифм по основанию e от X. Если X меньше или равно 0.0E0, функция возвращает NULL и выводится предупреждение “Неверный аргумент для логарифма”. Возвращает NULL, если X является NULL.
```
mysql> SELECT LN(2);
        -> 0.69314718055995
mysql> SELECT LN(-2);
        -> NULL
```
Эта функция является синонимом LOG(X). Обратной функцией является функция EXP().

LOG(X), LOG(B,X)

Если функция вызывается с одним параметром, она возвращает натуральный логарифм X. Если X меньше или равно 0.0E0, функция возвращает NULL и выводится предупреждение “Некорректный аргумент для логарифма”. Возвращает NULL, если X или B равны NULL.

Обратной функцией (при вызове с одним аргументом) является функция EXP().
```
mysql> SELECT LOG(2);
        -> 0.69314718055995
mysql> SELECT LOG(-2);
        -> NULL
```
Если функция вызывается с двумя параметрами, она возвращает логарифм X по основанию B. Если X меньше или равно 0, или B меньше или равно 1, то возвращается NULL.
```
mysql> SELECT LOG(2,65536);
        -> 16
mysql> SELECT LOG(10,100);
        -> 2
mysql> SELECT LOG(1,100);
        -> NULL
```
LOG(B,X) эквивалентна LOG(X) / LOG(B).
LOG2(X)

Возвращает логарифм по основанию 2 от X. Если X меньше или равно 0.0E0, функция возвращает NULL и выводится предупреждение “Некорректный аргумент для логарифма”. Возвращает NULL, если X равно NULL.
```
mysql> SELECT LOG2(65536);
        -> 16
mysql> SELECT LOG2(-100);
        -> NULL
```
LOG2() полезна для определения количества битов, необходимых для хранения числа. Эта функция эквивалентна выражению LOG(X) / LOG(2).
LOG10(X)

Возвращает логарифм по основанию 10 от X. Если X меньше или равно 0.0E0, функция возвращает NULL и выводится предупреждение “Некорректный аргумент для логарифма”. Возвращает NULL, если X равно NULL.
```
mysql> SELECT LOG10(2);
        -> 0.30102999566398
mysql> SELECT LOG10(100);
        -> 2
mysql> SELECT LOG10(-100);
        -> NULL
```
LOG10(X) эквивалентна LOG(10,X).
MOD(N,M), N % M, N MOD M

Операция modulo. Возвращает остаток от деления N на M. Возвращает NULL, если M или N равно NULL.
```
mysql> SELECT MOD(234, 10);
        -> 4
mysql> SELECT 253 % 7;
        -> 1
mysql> SELECT MOD(29,9);
        -> 2
mysql> SELECT 29 MOD 9;
        -> 2
```
Эта функция безопасна для использования с BIGINT значениями.

MOD() также работает со значениями, имеющими дробную часть, и возвращает точный остаток после деления:
```
mysql> SELECT MOD(34.5,3);
        -> 1.5
```
MOD(N,0) возвращает NULL.
PI()

Возвращает значение π (пи). По умолчанию отображается семь десятичных знаков, но MySQL использует полное значение двойной точности внутри.

Поскольку возвращаемое значение этой функции является значением двойной точности, его точное представление может отличаться между платформами или реализациями. Это также относится ко всем выражениям, использующим PI(). См. Раздел 13.1.4, “Типы с плавающей точкой (приближенное значение) - FLOAT, DOUBLE”.
```
mysql> SELECT PI();
        -> 3.141593
mysql> SELECT PI()+0.000000000000000000;
        -> 3.141592653589793000
```
POW(X,Y)

Возвращает значение X в степени Y. Возвращает NULL, если X или Y равно NULL.
```
mysql> SELECT POW(2,2);
        -> 4
mysql> SELECT POW(2,-2);
        -> 0.25
```
POWER(X,Y)

Это синоним для POW().
RADIANS(X)

Возвращает аргумент X, преобразованный из градусов в радианы. (Обратите внимание, что π радиан равно 180 градусам.) Возвращает NULL, если X равно NULL.
```
mysql> SELECT RADIANS(90);
        -> 1.5707963267949
```
RAND([N])

Возвращает случайное значение с плавающей точкой v в диапазоне 0 <= v < 1.0. Чтобы получить случайное целое число R в диапазоне i <= R < j, используйте выражение FLOOR(i + RAND() * (j − i)). Например, чтобы получить случайное целое число в диапазоне 7 <= R < 12, используйте следующее утверждение:
```
SELECT FLOOR(7 + (RAND() * 5));
```
Если указан целочисленный аргумент N, он используется в качестве значения семени:
- С константным аргументом инициализации, семя инициализируется один раз при подготовке оператора, до выполнения.
- С неконстантным аргументом инициализации (например, имя столбца), семя инициализируется для каждого вызова RAND().
Одно следствие этого поведения заключается в том, что для одинаковых значений аргументов RAND(N) возвращает одинаковое значение каждый раз и, следовательно, генерирует повторяющуюся последовательность значений столбцов. В приведенном ниже примере последовательность значений, производимых RAND(3), одинакова в обоих местах.
```
mysql> CREATE TABLE t (i INT);
Query OK, 0 rows affected (0.42 sec)

mysql> INSERT INTO t VALUES(1),(2),(3);
Query OK, 3 rows affected (0.00 sec)
Records: 3  Duplicates: 0  Warnings: 0

mysql> SELECT i, RAND() FROM t;
+------+------------------+
| i    | RAND()           |
+------+------------------+
|    1 | 0.61914388706828 |
|    2 | 0.93845168309142 |
|    3 | 0.83482678498591 |
+------+------------------+
3 rows in set (0.00 sec)

mysql> SELECT i, RAND(3) FROM t;
+------+------------------+
| i    | RAND(3)          |
+------+------------------+
|    1 | 0.90576975597606 |
|    2 | 0.37307905813035 |
|    3 | 0.14808605345719 |
+------+------------------+
3 rows in set (0.00 sec)

mysql> SELECT i, RAND() FROM t;
+------+------------------+
| i    | RAND()           |
+------+------------------+
|    1 | 0.35877890638893 |
|    2 | 0.28941420772058 |
|    3 | 0.37073435016976 |
+------+------------------+
3 rows in set (0.00 sec)

mysql> SELECT i, RAND(3) FROM t;
+------+------------------+
| i    | RAND(3)          |
+------+------------------+
|    1 | 0.90576975597606 |
|    2 | 0.37307905813035 |
|    3 | 0.14808605345719 |
+------+------------------+
3 rows in set (0.01 sec)
```
RAND() в предложении WHERE вычисляется для каждой строки (при выборке из одной таблицы) или комбинации строк (при выборке из соединения нескольких таблиц). Таким образом, для целей оптимизации RAND() не является постоянным значением и не может использоваться для оптимизации индексов. Дополнительную информацию см. в Разделе 10.2.1.20, “Оптимизация вызова функций”.

Использование столбца со значениями RAND() в предложении ORDER BY или GROUP BY может привести к непредсказуемым результатам, потому что для любого из предложений выражение RAND() может быть вычислено несколько раз для одной и той же строки, каждый раз возвращая разный результат. Если цель заключается в получении строк в случайном порядке, вы можете использовать оператор такого вида:
```
SELECT * FROM tbl_name ORDER BY RAND();
```
Чтобы выбрать случайную выборку из набора строк, объедините ORDER BY RAND() с LIMIT:
```
SELECT * FROM table1, table2 WHERE a=b AND c<d ORDER BY RAND() LIMIT 1000;
```
RAND() не предназначена для создания совершенного генератора случайных чисел. Это быстрый способ генерации случайных чисел по требованию, который портативен между платформами для одной и той же версии MySQL.

Эта функция небезопасна для репликации на основе операторов. Предупреждение записывается, если вы используете эту функцию, когда binlog_format установлено в STATEMENT.

ROUND(X), ROUND(X,D)

Округляет аргумент X до D знаков после запятой. Алгоритм округления зависит от типа данных X. D по умолчанию равно 0, если не указано иное. D может быть отрицательным, чтобы привести к обнулению D цифр слева от десятичной точки значения X. Максимальное абсолютное значение для D составляет 30; любые цифры свыше 30 (или -30) усекаются. Если X или D равны NULL, функция возвращает NULL.
```
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
mysql> SELECT ROUND(.12345678901234567890123456789012345, 35);
        -> 0.123456789012345678901234567890
```
Значение возврата имеет тот же тип, что и первый аргумент (предполагается, что это целое число, double или decimal). Это означает, что для целочисленного аргумента результат является целым числом (без десятичных знаков):
```
mysql> SELECT ROUND(150.000,2), ROUND(150,2);
+------------------+--------------+
| ROUND(150.000,2) | ROUND(150,2) |
+------------------+--------------+
|           150.00 |          150 |
+------------------+--------------+
```
ROUND() использует следующие правила в зависимости от типа первого аргумента:
- Для чисел с точным значением, ROUND() использует правило “округление при половине в сторону от нуля” или “округление к ближайшему”: значение с дробной частью 0,5 или больше округляется вверх до ближайшего целого числа, если положительное, или вниз, если отрицательное. (Другими словами, оно округляется от нуля.) Значение с дробной частью меньше 0,5 округляется вниз до ближайшего целого числа, если положительное, или вверх, если отрицательное.
- Для чисел с приближенным значением, результат зависит от библиотеки C. На многих системах это означает, что ROUND() использует правило “округление к ближайшему четному”: значение с дробной частью ровно посередине между двумя целыми числами округляется до ближайшего четного целого числа.
Следующий пример демонстрирует, как округление отличается для точных и приближенных значений:
```
mysql> SELECT ROUND(2.5), ROUND(25E-1);
+------------+--------------+
| ROUND(2.5) | ROUND(25E-1) |
+------------+--------------+
| 3          |            2 |
+------------+--------------+
```
Для получения дополнительной информации, см. Раздел 14.24, «Точность вычислений».

Тип данных, возвращаемый ROUND() (и TRUNCATE()), определяется в соответствии с приведенными здесь правилами:
- Когда первый аргумент является целого типа, тип возвращаемого значения всегда BIGINT.
- Когда первый аргумент является типа с плавающей точкой или любого не числового типа, тип возвращаемого значения всегда DOUBLE.
- Когда первый аргумент является значением DECIMAL, тип возврата также DECIMAL.
- Атрибуты типа для возвращаемого значения также копируются из первого аргумента, за исключением случая DECIMAL, когда второй аргумент имеет константное значение.
  
  Когда желаемое количество знаков после запятой меньше масштаба аргумента, масштаб и точность результата корректируются соответственно.
  
  Кроме того, для ROUND() (но не для функции TRUNCATE()) точность увеличивается на один разряд для размещения округления, которое увеличивает количество значащих цифр. Если второй аргумент отрицательный, тип возврата корректируется таким образом, что его масштаб равен 0, с соответствующей точностью. Например, ROUND(99.999, 2) возвращает 100.00 — первый аргумент является DECIMAL(5, 3), а тип возврата является DECIMAL(5, 2).
  
  Если второй аргумент отрицательный, тип возврата имеет масштаб 0 и соответствующую точность; ROUND(99.999, -1) возвращает 100, что является DECIMAL(3, 0).
SIGN(X)

Возвращает знак аргумента как -1, 0 или 1, в зависимости от того, является ли X отрицательным, нулевым или положительным. Возвращает NULL, если X равно NULL.
```
mysql> SELECT SIGN(-32);
        -> -1
mysql> SELECT SIGN(0);
        -> 0
mysql> SELECT SIGN(234);
        -> 1
```
SIN(X)

Возвращает синус X, где X задано в радианах. Возвращает NULL, если X равно NULL.
```
mysql> SELECT SIN(PI());
        -> 1.2246063538224e-16
mysql> SELECT ROUND(SIN(PI()));
        -> 0
```
SQRT(X)

Возвращает квадратный корень из неотрицательного числа X. Если X равно NULL, функция возвращает NULL.
```
mysql> SELECT SQRT(4);
        -> 2
mysql> SELECT SQRT(20);
        -> 4.4721359549996
mysql> SELECT SQRT(-16);
        -> NULL
```
TAN(X)

Возвращает тангенс X, где X задано в радианах. Возвращает NULL, если X равно NULL.
```
mysql> SELECT TAN(PI());
        -> -1.2246063538224e-16
mysql> SELECT TAN(PI()+1);
        -> 1.5574077246549
```
TRUNCATE(X,D)

Возвращает число X, усечённое до D знаков после запятой. Если D равно 0, результат не имеет десятичной точки или дробной части. D может быть отрицательным, чтобы привести к обнулению D цифр слева от десятичной точки значения X. Если X или D равны NULL, функция возвращает NULL.
```
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
```
Все числа округляются к нулю.

Тип данных, возвращаемый TRUNCATE(), следует тем же правилам, что определяют тип возвращаемого значения функции ROUND(); для получения подробной информации см. описание функции ROUND().