12.6.2 Mathematical Functions — MySQL 5.7

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

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

Таблица 12.10 Математические функции
Имя	Описание
`ABS()`	Возвращает абсолютное значение
`ACOS()`	Возвращает арккосинус
`ASIN()`	Возвращает арксинус
`ATAN()`	Возвращает арктангенс
`ATAN2()`, `ATAN()`	Возвращает арктангенс от двух аргументов
`CEIL()`	Возвращает наименьшее целое значение, не меньшее, чем аргумент
`CEILING()`	Возвращает наименьшее целое значение, не меньшее, чем аргумент
`CONV()`	Преобразует числа между различными системами счисления
`COS()`	Возвращает косинус
`COT()`	Возвращает котангенс
`CRC32()`	Вычисляет значение контрольной суммы 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.
```
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.

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.
```
mysql> SELECT ATAN(2);
        -> 1.1071487177941
mysql> SELECT ATAN(-2);
        -> -1.1071487177941
```
ATAN(Y,X), ATAN2(Y,X)

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

CEIL() — синоним функции CEILING().
CEILING(X)

Возвращает наименьшее целое значение, не меньшее, чем X.
```
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-битной точностью.
```
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 задано в радианах.
```
mysql> SELECT COS(PI());
        -> -1
```

COT(X)

Возвращает котангенс X.

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, преобразованный из радиан в градусы.
```
mysql> SELECT DEGREES(PI());
        -> 180
mysql> SELECT DEGREES(PI() / 2);
        -> 90
```
EXP(X)

Возвращает значение e (основание натурального логарифма) в степени X. Обратная функция — LOG() (только с одним аргументом) или LN().
```
mysql> SELECT EXP(2);
        -> 7.3890560989307
mysql> SELECT EXP(-2);
        -> 0.13533528323661
mysql> SELECT EXP(0);
        -> 1
```
FLOOR(X)

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

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

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

Возвращает натуральный логарифм X, то есть логарифм по основанию e от X. Если X меньше или равно 0.0E0, функция возвращает 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 и выводится предупреждение “Неверный аргумент для логарифма”.

Обратная функция (при вызове с одним аргументом) — функция 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 и выводится предупреждение “Неверный аргумент для логарифма”.
```
mysql> SELECT LOG2(65536);
        -> 16
mysql> SELECT LOG2(-100);
        -> NULL
```
LOG2() полезна для определения того, сколько бит требуется для хранения числа. Эта функция эквивалентна выражению LOG(X) / LOG(2).

END_OF_DOCUMENT_MARKER

LOG10(X)

Возвращает десятичный логарифм от X. Если X меньше или равно 0.0E0, функция возвращает 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

Операция взятия остатка от деления. Возвращает остаток от деления N на M.
```
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(). См. Раздел 11.1.4 «Числа с плавающей точкой (приближённое значение) - FLOAT, DOUBLE».
```
mysql> SELECT PI();
        -> 3.141593
mysql> SELECT PI()+0.000000000000000000;
        -> 3.141592653589793000
```

POW(X,Y)

Возвращает значение X в степени Y.

mysql> SELECT POW(2,2);
        -> 4
mysql> SELECT POW(2,-2);
        -> 0.25

POWER(X,Y)

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

Возвращает аргумент X, преобразованный из градусов в радианы. (Обратите внимание, что π радиан равно 180 градусам.)
```
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() не является константой и не может использоваться для оптимизации индексов. Дополнительную информацию см. в Разделе 8.2.1.18 «Оптимизация вызова функции».

Использование столбца со значениями 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), отбрасываются.
```
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 |
+------------+--------------+
```
Дополнительную информацию см. в Разделе 12.21 «Точность математических вычислений».
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

END_OF_DOCUMENT_MARKER

TAN(X)

Возвращает тангенс X, где X задано в радианах.

mysql> SELECT TAN(PI());
        -> -1.2246063538224e-16
mysql> SELECT TAN(PI()+1);
        -> 1.5574077246549

TRUNCATE(X,D)

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