14.6.2 Mathematical Functions — MySQL 9.2

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, и выводится предупреждение “Invalid argument for logarithm”. Возвращает 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
```
Значение результата имеет тот же тип, что и первый аргумент (предполагается, что это целое число, двойное число или десятичное). Это означает, что для целочисленного аргумента результат является целым числом (без десятичных знаков):
```
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.25, “Точность вычислений”.

Тип данных, возвращаемый 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().