ABS(X)
X의 절대 값을 리턴한다.
mysql> SELECT ABS(2);
-> 2
mysql> SELECT ABS(-32);
-> 32
이 함수는 BIGINT 값과 함께 사용하는 것이 안전하다.
ACOS(X)
X의 아크 코사인(arc cosine) 값을 리턴한다. 즉, 코사인이 X인 값을
리턴한다. 만일 X 가 -1 에서 1 사이의 범위에 있지 않으면, NULL을
리턴한다.
mysql> SELECT ACOS(1);
-> 0
mysql> SELECT ACOS(1.0001);
-> NULL
mysql> SELECT ACOS(0);
-> 1.5707963267949
ASIN(X)
X 의 아크 사인 값(arc sine)을 리턴 한다. 즉 사인 값이 X인 값.
만일 X 가 -1 에서 1 사이의 범위에 있지 않으면, 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)
Returns the arc tangent of X의 아크 탄젠트(arc tangent) 값을 리턴한다.
즉, 탄젠트가 X인 값.
mysql> SELECT ATAN(2);
-> 1.1071487177941
mysql> SELECT ATAN(-2);
-> -1.1071487177941
ATAN(Y,X), ATAN2(Y,X)
두 변수 X 와 Y의 아크 탄젠트 값을 리턴한다. 이것은 Y / X의 아크 탄젠트
값을 계산하는 방식과 유사하지만, 두 인수의 부호는 결과에 대한 쿼드런트
(quadrant)를 알아내기 위해 사용된다는 점은 틀리다.
mysql> SELECT ATAN(-2,2);
-> -0.78539816339745
mysql> SELECT ATAN2(PI(),0);
-> 1.5707963267949
CEILING(X), CEIL(X)
X 보다는 작지 않은 가장 작은 정수 값을 리턴한다.
mysql> SELECT CEILING(1.23);
-> 2
mysql> SELECT CEIL(-1.23);
-> -1
위의 두 함수는 동일한 것이다. 리턴 값은 BIGINT으로 변환된다는
점은 알아 두자.
COS(X)
X 의 코사인 값을 리턴 하는데, 여기에서 X 는 레디안(radian)으로
주어진다.
mysql> SELECT COS(PI());
-> -1
COT(X)
X 의 코 탄젠트 값을 리턴한다.
mysql> SELECT COT(12);
-> -1.5726734063977
mysql> SELECT COT(0);
-> NULL
CRC32(expr)
싸이클릭 리던던시 체크 값 (cyclic redundancy check value)을 계산한
다음에 32-비트 부호화되지 않은 값을 리턴한다. 인수가 NULL이면 NULL
을 리턴한다. 인수는 스트링 값이 되어야 한다.
mysql> SELECT CRC32('MySQL');
-> 3259397556
mysql> SELECT CRC32('mysql');
-> 2501908538
DEGREES(X)
인수 X를 리턴하는데, 레디안에서 차수 (degree)로 변경된 값이 나온다.
mysql> SELECT DEGREES(PI());
-> 180
mysql> SELECT DEGREES(PI() / 2);
-> 90
EXP(X)
X 의 제곱에 대한 e (자연 로그 근) 값을 리턴한다.
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);
-> 1
mysql> SELECT FLOOR(-1.23);
-> -2
리턴 값이 BIGINT로 변환 된다는 점을 알아 두자.
FORMAT(X,D)
숫자 X 의 형태를 '#,###,###.##'로 변경 시키고, D 자릿수 위치에서
절사를 한 다음에, 그 결과를 스트링으로 리턴한다. 보다 자세한
사항은, Section 12.3, “스트링 함수”를 참조할 것.
LN(X)
X의 자연 로그를 리턴한다; 즉, X의 베이스-e 로그.
mysql> SELECT LN(2);
-> 0.69314718055995
mysql> SELECT LN(-2);
-> NULL
이 함수는 LOG(X)과 동의어 이다.
LOG(X), LOG(B,X)
만일 하나의 파라미터를 사용해서 호출이 되면, 이 함수는 X의 자연
로그를 리턴한다.
mysql> SELECT LOG(2);
-> 0.69314718055995
mysql> SELECT LOG(-2);
-> NULL
만일 두 개의 파라미터를 사용해서 호출을 하면, 이 함수는 부정 베이스
(arbitrary base) B 에 대한 X의 자연 로그를 리턴 한다.
mysql> SELECT LOG(2,65536);
-> 16
mysql> SELECT LOG(10,100);
-> 2
LOG(B,X)는 LOG(X) / LOG(B)과 동의어 이다.
LOG2(X)
X의 베이스-e 로그를 리턴한다.
mysql> SELECT LOG2(65536);
-> 16
mysql> SELECT LOG2(-100);
-> NULL
LOG2()는 스토리지용으로 필요한 비트의 수가 얼마나 되는지를 알아
보는데 유용하다. 이 함수는 LOG(X) / LOG(2)과 동일하다.
LOG10(X)
X의 베이스-10 로그를 리턴한다.
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
모듈러 연산. M으로 나누어진 N의 나머지를 리턴한다.
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
PI()
π (pi) 값을 리턴 한다. 출력되는 기본 자릿수는 7 자리이지만,
MySQL은 내부적으로는 전 이중 정밀도(full double-precision)
값을 사용한다.
mysql> SELECT PI();
-> 3.141593
mysql> SELECT PI()+0.000000000000000000;
-> 3.141592653589793116
POW(X,Y), POWER(X,Y)
Y 제곱이 된 X 값을 리턴한다.
mysql> SELECT POW(2,2);
-> 4
mysql> SELECT POW(2,-2);
-> 0.25
RADIANS(X)
각도를 레디안으로 변경한 인수 X를 리턴한다. (π 레디안은 180 도와
동일하다.)
mysql> SELECT RADIANS(90);
-> 1.5707963267949
RAND(), RAND(N)
0 과 1 사이의 무작위 부정 소수점 값 v 를 리턴한다 (즉, 0 <= v <= 1.0
사이의 범위). 만일 정수 인수 N이 지정 되었다면, 이것은 시드 값
(seed value)로 사용되며, 반복 시퀀스를 만들어 낸다.
mysql> SELECT RAND();
-> 0.9233482386203
mysql> SELECT RAND(20);
-> 0.15888261251047
mysql> SELECT RAND(20);
-> 0.15888261251047
mysql> SELECT RAND();
-> 0.63553050033332
mysql> SELECT RAND();
-> 0.70100469486881
mysql> SELECT RAND(20);
-> 0.15888261251047
i <= R <= j 범위에서 임의적으로 정수 R 을 얻기 위해서는, 수식
FLOOR(i + RAND() * (j – i)을 사용한다.
예를 들면, 1에서 12 사이의 범위에서 임의의 정수를 얻고자 한다면,
아래의 명령문을 사용하면 된다:
SELECT FLOOR(7 + (RAND() * 5));
ORDER BY 구문에서는 RAND() 값을 사용하는 컬럼을 사용할 수가
없는데, 그 이유는 ORDER BY가 그 컬럼을 여러 번 계산하기 때문이다.
하지만, 아래와 같이 무작위로 열을 추출할 수는 있다:
mysql> SELECT * FROM tbl_name ORDER BY RAND();
LIMIT과 결합이 된 ORDER BY RAND()는 열로 이루어진 셋에서 무작위
샘플을 선택하는 경우에 유용하게 사용할 수가 있다:
mysql> SELECT * FROM table1, table2 WHERE a=b AND c<d
-> ORDER BY RAND() LIMIT 1000;
WHERE 구문에 있는 RAND()는 WHERE 구문이 실행될 때마다 반복적으로
계산된다는 점을 알아 두기 바란다.
RAND()는 완벽한 무작위 제너레이터는 아니지만, 동일 MySQL 버전을
사용하고 있는 플랫폼간에 이식성이 있는 ad hoc 랜덤 숫자를 만들기
에는 속도가 빠른 방식이다.
ROUND(X), ROUND(X,D)
인수 X를 리턴 하는데, 이때에는 이와 가장 가까운 정수로 절사가 된다.
두 개의 인수를 사용하면, D 자릿수에서 절사가 된 X 가 리턴 된다.
D 는 음수로 표시될 수도 있는데, 이렇게 하면 소수점에서 왼쪽으로
D 자리에 있는 X 의 값이 0 이 된다.
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 5.0.3 이전에는, 인수가 두 개의 정수 사이의 절반에 해당될
때 ROUND()는 C 라이브러리의 실행에 따라서 값을 리턴 했다. 이
방식은 항상 반올림, 잘라냄, 0으로 만들기와 같은 방식을 취했다.
만일 한 가지 방식의 절사 (rounding) 방식만을 사용하고자 할
경우에는 TRUNCATE() 또는 FLOOR()와 같은 함수를 대신
사용하는 것이 좋다. MySQL 5.0.3 이후에는, ROUND()는
첫 번째 인수가 10진수 값일 경우에는 정확한 인수 값을
얻기 위해서 정밀도 수학 라이브러리(precision math library)를
사용한다:
정확한 숫자를 얻기 위해서, ROUND()는 “반올림 (round half up)”
또는 “가장 가까운 값으로 절사 (round toward nearest)” 규칙을
사용한다: 어떤 수의 소수점 이하 부분이 .5 보다 크거나 같을 경우
에는, 그 수가 양수라면 바로 다음의 정수로, 그 수가 음수일 경우에는,
바로 이전 정수로 절사 (round)를 한다 (즉, 소수 부분을 0 으로 만든다).
소수점 이하의 숫자가 .5보다 작을 경우에는, 그 수가 양수라면 바로
이전 정수로, 음수일 경우에는 바로 다음 정수로 된다.
추정 값 숫자에 대해서는, C 라이브러리에 따라서 그 결과가 나온다.
대부분의 시스템에서는, ROUND()가 "가장 근접한 짝수로 절사
(round to nearest even)" 규칙을 사용한다: 소수점 이하 부분이 있는
값은 가장 근접한 정수로 된다.
아래의 예문은 정확한 값과 추정 값을 어떻게 서로 다르게 라운딩 (rounding)
하는지를 보여준다:
mysql> SELECT ROUND(2.5), ROUND(25E-1);
+------------+--------------+
| ROUND(2.5) | ROUND(25E-1) |
+------------+--------------+
| 3 | 2 |
+------------+--------------+
보다 자세한 정보는, Chapter 21, Precision Math를 참고한다.
SIGN(X)
인수의 부호를 -1, 0, 또는 1로 리턴 하는데, 여기에서 리턴 되는 숫자는
각각 음수, 0, 양수를 나타내는 것이다.
mysql> SELECT SIGN(-32);
-> -1
mysql> SELECT SIGN(0);
-> 0
mysql> SELECT SIGN(234);
-> 1
SIN(X)
래디안으로 주어진 X의 싸인(sin) 값을 리턴 한다.
mysql> SELECT SIN(PI());
-> 1.2246063538224e-16
mysql> SELECT ROUND(SIN(PI()));
-> 0
SQRT(X)
음수가 아닌 X의 제곱 루트(square root) 값을 리턴한다.
mysql> SELECT SQRT(4);
-> 2
mysql> SELECT SQRT(20);
-> 4.4721359549996
mysql> SELECT SQRT(-16);
-> NULL
TAN(X)
래디안으로 주어진 X의 탄젠트 값을 리턴한다.
mysql> SELECT TAN(PI());
-> -1.2246063538224e-16
mysql> SELECT TAN(PI()+1);
-> 1.5574077246549
TRUNCATE(X,D)
숫자 X를 D 자릿수 뒤의 숫자를 없앤 후 리턴한다. 만일 D가 0 이면,
리턴되는 숫자는 소수점 또는 소수 부분이 없게 된다. D는 음수로
표시할 수도 있는데, 이렇게 표시하면 숫자 X의 D 자리로부터 왼쪽
부분이 0으로 표시가 된다.
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
