Сообщить об ошибке.

MySQL: Математические функции.

Все математические функции БД MySQL возвращают NULL в случае ошибки.

Содержание:


ABS(X):

MySQL функция ABS() возвращает абсолютное значение X или NULL, если X равно NULL.

Тип результата является производным от типа аргумента. Следствием этого является то, что ABS(-9223372036854775808) выдает ошибку, поскольку результат не может быть сохранен в значении BIGINT со знаком.

mysql> SELECT ABS(2);
        -> 2
mysql> SELECT ABS(-32);
        -> 32

Эту функцию безопасно использовать со значениями BIGINT.

ACOS(X):

MySQL функция ACOS() возвращает косинус дуги 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):

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

mysql> SELECT ASIN(0.2);
        -> 0.20135792079033
mysql> SELECT ASIN('foo');
        -> 0

mysql> SHOW WARNINGS;
+---------+------+-----------------------------------------+
| Warning | 1292 | Truncated incorrect DOUBLE value: 'foo' |
+---------+------+-----------------------------------------+

ATAN(X):

MySQL функция ATAN() возвращает тангенс дуги X, то есть значение, тангенс которого равен X. Возвращает значение NULL, если X равно NULL.

mysql> SELECT ATAN(2);
        -> 1.1071487177941
mysql> SELECT ATAN(-2);
        -> -1.1071487177941

ATAN(Y,X),
ATAN2(Y,X):

MySQL функция ATAN2() возвращает тангенс дуги двух переменных X и Y. Это похоже на вычисление тангенса дуги Y/X, за исключением того, что знаки обоих аргументов используются для определения квадранта результата. Возвращает значение NULL, если X или Y равно NULL.

mysql> SELECT ATAN(-2,2);
        -> -0.78539816339745
mysql> SELECT ATAN2(PI(),0);
        -> 1.5707963267949

CEIL(X):

MySQL функция CEIL() возвращает наименьшее целое значение, не меньшее X. Возвращает значение NULL, если X равно NULL.

mysql> SELECT CEILING(1.23);
        -> 2
mysql> SELECT CEILING(-1.23);
        -> -1

Для числовых аргументов с точным значением возвращаемое значение имеет числовой тип с точным значением. Для строковых аргументов или аргументов с плавающей запятой возвращаемое значение имеет тип с плавающей запятой.

CONV(N, from_base, to_base):

MySQL функция CONV() преобразует числа между различными числовыми базами. Возвращает строковое представление числа 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):

MySQL функция COS() возвращает косинус X, где X дается в радианах. Возвращает NULL, если X равен NULL.

mysql> SELECT COS(PI());
        -> -1

COT(X):

MySQL функция COT() возвращает котангенс X. Возвращает значение NULL, если X равно NULL.

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

CRC32(expr):

MySQL функция CRC32() вычисляет значение проверки циклической избыточности и возвращает 32-разрядное значение без знака. Результат равен NULL, если аргумент равен NULL. Ожидается, что аргумент будет строкой. Если это не так, то обрабатывается как строка.

mysql> SELECT CRC32('MySQL');
        -> 3259397556
mysql> SELECT CRC32('mysql');
        -> 2501908538

DEGREES(X):

MySQL функция DEGREES() возвращает аргумент X, преобразованный из радианов в градусы. Возвращает значение NULL, если X равно NULL.

mysql> SELECT DEGREES(PI());
        -> 180
mysql> SELECT DEGREES(PI() / 2);
        -> 90

EXP(X):

MySQL функция EXP() возвращает значение 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):

MySQL функция FLOOR() возвращает наибольшее целое значение, не превышающее X. Возвращает значение NULL, если X равно NULL.

mysql> SELECT FLOOR(1.23), FLOOR(-1.23);
        -> 1, -2

Для числовых аргументов с точным значением возвращаемое значение имеет числовой тип с точным значением. Для строковых аргументов или аргументов с плавающей запятой возвращаемое значение имеет тип с плавающей запятой.

LN(X):

MySQL функция LN() возвращает натуральный логарифм X, то есть логарифм по основанию 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):

При вызове функция LOG() с одним параметром, она возвращает натуральный логарифм X. Если X меньше или равно 0,0E0, функция возвращает NULL и выдается предупреждение "Invalid argument for logarithm". Возвращает значение NULL, если X или B имеет значение NULL.

Инверсией этой функции (при вызове с одним аргументом) является функция EXP().

mysql> SELECT LOG(2);
        -> 0.69314718055995
mysql> SELECT LOG(-2);
        -> NULL

При вызове с двумя параметрами функция LOG() возвращает логарифм 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):

MySQL функция LOG2() возвращает логарифм по основанию 2 от X. Если X меньше или равно 0.0E0, то функция возвращает значение NULL и выдается предупреждение "Invalid argument for logarithm". Возвращает значение NULL, если X равно NULL.

mysql> SELECT LOG2(65536);
        -> 16
mysql> SELECT LOG2(-100);
        -> NULL

Функция LOG2() полезна для определения того, сколько битов требуется для хранения числа. Эта функция эквивалентна выражению LOG(X)/LOG(2).

LOG10(X):

MySQL функция LOG10() возвращает логарифм по основанию 10 от X. Если X меньше или равно 0.0E0, то функция возвращает значение NULL и выдается предупреждение "Invalid argument for logarithm". Возвращает значение 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:

MySQL функция MOD() представляет собой операции по модулю. Возвращает остаток от 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() возвращает значение значение π (pi). Отображаемое количество знаков после запятой по умолчанию равно семи, но MySQL внутренне использует полное значение двойной точности.

mysql> SELECT PI();
        -> 3.141593
mysql> SELECT PI()+0.000000000000000000;
        -> 3.141592653589793116

POW(X,Y):

MySQL функция POW() возвращает значение X, возведенное в степень Y. Возвращает значение NULL, если X или Y равно NULL.

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

RADIANS(X):

MySQL функция RADIANS() возвращает аргумент X, преобразованный из градусов в радианы. (Обратите внимание, что π радиан равен 180 градусам.) Возвращает значение NULL, если X равно NULL.

mysql> SELECT RADIANS(90);
        -> 1.5707963267949

RAND([N]):

MySQL функция RAND() возвращает случайное значение с плавающей запятой 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);

mysql> INSERT INTO t VALUES(1),(2),(3);
Records: 3  Duplicates: 0  Warnings: 0

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

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

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

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

Функция RAND() в предложении WHERE оценивается для каждой строки (при выборе из одной таблицы) или комбинации строк (при выборе из объединения нескольких таблиц). Таким образом, для целей оптимизатора RAND() не является постоянным значением и не может использоваться для оптимизации индекса.

Использование столбца со значениями 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):

MySQL функция ROUND() округляет аргумент 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);
        -> 150.00, 150

Функция ROUND() использует следующие правила в зависимости от типа первого аргумента:

  • Для чисел с точным значением функция ROUND() использует правило "округления наполовину от нуля" или "округления в сторону ближайшего": значение с дробной частью 0.5 или больше округляется до следующего целого числа, если оно положительное, или до следующего целого числа, если отрицательное. Другими словами, оно округляется от нуля. Значение с дробной частью меньше 0.5 округляется до следующего целого числа, если оно положительное, или до следующего целого числа, если оно отрицательное.
  • Для чисел с приблизительным значением результат зависит от библиотеки языка C. Во многих системах это означает, что ROUND() использует правило "округления до ближайшего четного": значение, дробная часть которого ровно посередине между двумя целыми числами, округляется до ближайшего четного целого числа.

В следующем примере показано, как отличается округление для точных и приблизительных значений:

mysql> SELECT ROUND(2.5), ROUND(25E-1);
        -> 3, 2

В MySQL 8.0.21 и более поздних версиях тип данных, возвращаемый функцией 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):

MySQL функция SIGN() возвращает знак аргумента как -1, 0 или 1, в зависимости от того, является ли X отрицательным, нулевым или положительным. Возвращает значение NULL, если X равно NULL.

mysql> SELECT SIGN(-32);
        -> -1
mysql> SELECT SIGN(0);
        -> 0
mysql> SELECT SIGN(234);
        -> 1

SIN(X):

MySQL функция SIN() возвращает синус X, где X задается в радианах. Возвращает значение NULL, если X равно NULL.

mysql> SELECT SIN(PI());
        -> 1.2246063538224e-16
mysql> SELECT ROUND(SIN(PI()));
        -> 0

SQRT(X):

MySQL функция SQRT() возвращает квадратный корень из неотрицательного числа X. Если X равно NULL, функция возвращает значение NULL.

mysql> SELECT SQRT(4);
        -> 2
mysql> SELECT SQRT(20);
        -> 4.4721359549996
mysql> SELECT SQRT(-16);
        -> NULL

TAN(X):

MySQL функция TAN() возвращает тангенс X, где X передается в радианах. Возвращает NULL, если X равен NULL.

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

TRUNCATE(X,D):

MySQL функция TRUNCATE() возвращает число 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

Все числа округлены до нуля.

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

OCT(N):

MySQL функция OCT() возвращает строковое представление восьмеричного значения N, где N - длинное (BIGINT) число. Это эквивалентно CONV(N,10,8). Возвращает значение NULL, если N равно NULL.

mysql> SELECT OCT(12);
        -> '14'
mysql> SELECT CONV(12,10,8);
        -> '14'

HEX(str),
HEX(N):

Для строкового аргумента str, MySQL функция HEX() возвращает шестнадцатеричное строковое представление str, где каждый байт каждого символа в str преобразуется в две шестнадцатеричные цифры. Поэтому многобайтовые символы становятся более чем двумя цифрами. Обратное этой операции выполняется функцией UNHEX().

Для числового аргумента N, функция HEX() возвращает шестнадцатеричное строковое представление значения N, рассматриваемого как длинное (BIGINT) число. Это эквивалентно CONV(N,10,16). Обратное этой операции выполняется с помощью `CONV(HEX(N),16,10).

Если аргумент равен NULL, то эта функция возвращает NULL.

mysql> SELECT X'616263', HEX('abc'), UNHEX(HEX('abc'));
        -> 'abc', 616263, 'abc'
mysql> SELECT HEX(255), CONV(HEX(255),16,10);
        -> 'FF', 255

UNHEX(str):

Для строкового аргумента str, MySQL функция UNHEX() интерпретирует каждую пару символов в аргументе как шестнадцатеричное число и преобразует его в байт, представленный числом. Возвращаемое значение представляет собой двоичную строку.

mysql> SELECT UNHEX('4D7953514C');
        -> 'MySQL'
mysql> SELECT X'4D7953514C';
        -> 'MySQL'
mysql> SELECT UNHEX(HEX('string'));
        -> 'string'
mysql> SELECT HEX(UNHEX('1267'));
        -> '1267'

Символы в строковом аргументе должны быть допустимыми шестнадцатеричными цифрами: '0' .. '9', 'A' .. 'F', 'a' .. 'f'. Если аргумент содержит какие-либо не шестнадцатеричные цифры или сам имеет значение NULL, то результатом будет NULL:

mysql> SELECT UNHEX('GG');
        -> NULL
mysql> SELECT UNHEX(NULL);
        -> NULL

Нулевой результат также может возникнуть, если аргумент UNHEX() является столбцом c типом BINARY, поскольку значения дополняются байтами 0x00 при сохранении, но эти байты не удаляются при извлечении. Например, '41' сохраняется в столбце CHAR(3) как '41' и извлекается как '41' (с удаленным пробелом в конце), поэтому UNHEX() для значения столбца возвращает X'41'. В отличие от этого, '41' сохраняется в BINARY(3) столбце как '41\0' и извлекается как '41\0' (при этом завершающий пробел 0x00 байт не удален). '\0' не является допустимой шестнадцатеричной цифрой, поэтому функция UNHEX() для значения столбца возвращает значение NULL.

Для числового аргумента N обратное значение HEX(N) не выполняется UNHEX(). Вместо этого используйте CONV(HEX(N),16,10). Смотрите описание HEX().