14.6.2 Mathematical Functions

14.6.2 Mathematical Functions

Table 14.10 Mathematical Functions

Name	Description
ABS()	절대값을 반환
ACOS()	아크 코사인을 반환
ASIN()	아크 사인을 반환
ATAN()	아크 탄젠트를 반환
ATAN2(), ATAN()	두 인자의 아크 탄젠트를 반환
CEIL()	인자보다 작지 않은 가장 작은 정수 값을 반환
CEILING()	인자보다 작지 않은 가장 작은 정수 값을 반환
CONV()	서로 다른 진수 사이에서 숫자를 변환
COS()	코사인을 반환
COT()	코탄젠트를 반환
CRC32()	순환 중복 검사 값을 계산
DEGREES()	라디안을 도(degree)로 변환
EXP()	지수 승을 계산
FLOOR()	인자보다 크지 않은 가장 큰 정수 값을 반환
LN()	인자의 자연 로그를 반환
LOG()	첫 번째 인자의 자연 로그를 반환
LOG10()	인자의 밑-10 로그를 반환
LOG2()	인자의 밑-2 로그를 반환
MOD()	나머지 값을 반환
PI()	π 값을 반환
POW()	인자를 지정된 거듭제곱으로 올린 값을 반환
POWER()	인자를 지정된 거듭제곱으로 올린 값을 반환
RADIANS()	인자를 라디안으로 변환하여 반환
RAND()	임의의 부동 소수점 값을 반환
ROUND()	인자를 반올림
SIGN()	인자의 부호를 반환
SIN()	인자의 사인을 반환
SQRT()	인자의 제곱근을 반환
TAN()	인자의 탄젠트를 반환
TRUNCATE()	지정된 소수 자릿수까지 버림

Name	Description

모든 수학 함수는 오류가 발생하면 NULL을 반환합니다.

• ABS(X)

_X_의 절대값을 반환하거나, _X_가 NULL이면 NULL을 반환합니다.

결과 타입은 인자 타입으로부터 유도됩니다. 이의 한 귀결은 ABS(-9223372036854775808) 이 결과를 signed BIGINT 값에 저장할 수 없기 때문에 오류를 생성한다는 점입니다.

1mysql> SELECT ABS(2);
2          -> 2
3mysql> SELECT ABS(-32);
4          -> 32

이 함수는 BIGINT 값에 대해 안전하게 사용할 수 있습니다.

• ACOS(X)

_X_의 아크 코사인, 즉 코사인이 _X_인 값을 반환합니다. _X_가 -1에서 1 범위에 있지 않거나 _X_가 NULL이면 NULL을 반환합니다.

1mysql> SELECT ACOS(1);
2          -> 0
3mysql> SELECT ACOS(1.0001);
4          -> NULL
5mysql> SELECT ACOS(0);
6          -> 1.5707963267949

• ASIN(X)

_X_의 아크 사인, 즉 사인이 _X_인 값을 반환합니다. _X_가 -1에서 1 범위에 있지 않거나 _X_가 NULL이면 NULL을 반환합니다.

1mysql> SELECT ASIN(0.2);
2          -> 0.20135792079033
3mysql> SELECT ASIN('foo');
4
5+-------------+
6| ASIN('foo') |
7+-------------+
8|           0 |
9+-------------+
101 row in set, 1 warning (0.00 sec)
11
12mysql> SHOW WARNINGS;
13+---------+------+-----------------------------------------+
14| Level   | Code | Message                                 |
15+---------+------+-----------------------------------------+
16| Warning | 1292 | Truncated incorrect DOUBLE value: 'foo' |
17+---------+------+-----------------------------------------+

• ATAN(X)

_X_의 아크 탄젠트, 즉 탄젠트가 _X_인 값을 반환합니다. _X_가 NULL이면 _NULL_을 반환합니다.

1mysql> SELECT ATAN(2);
2          -> 1.1071487177941
3mysql> SELECT ATAN(-2);
4          -> -1.1071487177941

• ATAN(Y,X), ATAN2(Y,X)

두 변수 _X_와 _Y_의 아크 탄젠트를 반환합니다. 이는 Y / X의 아크 탄젠트를 계산하는 것과 비슷하지만, 두 인자의 부호를 사용하여 결과의 사분면을 결정합니다. X 또는 _Y_가 NULL이면 NULL을 반환합니다.

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

• CEIL(X)

CEIL()은 CEILING()의 동의어입니다.

• CEILING(X)

_X_보다 작지 않은 가장 작은 정수 값을 반환합니다. _X_가 NULL이면 NULL을 반환합니다.

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

정확값 숫자 인자의 경우, 반환 값은 정확값 숫자 타입입니다. 문자열 또는 부동 소수점 인자의 경우, 반환 값은 부동 소수점 타입입니다.

• CONV(N,from_base,to_base)

서로 다른 진수 사이에서 숫자를 변환합니다. 숫자 _N_을 진수 _from_base_에서 진수 _to_base_로 변환한 문자열 표현을 반환합니다. 어떤 인자라도 NULL이면 NULL을 반환합니다. 인자 _N_은 정수로 해석되지만, 정수 또는 문자열로 지정할 수 있습니다. 최소 진수는 2이고 최대 진수는 36입니다. _from_base_가 음수이면 _N_은 signed 숫자로 간주됩니다. 그렇지 않으면 _N_은 unsigned로 취급됩니다. CONV()는 64비트 정밀도로 동작합니다.

CONV()는 인자 중 하나라도 NULL이면 NULL을 반환합니다.

1mysql> SELECT CONV('a',16,2);
2          -> '1010'
3mysql> SELECT CONV('6E',18,8);
4          -> '172'
5mysql> SELECT CONV(-17,10,-18);
6          -> '-H'
7mysql> SELECT CONV(10+'10'+'10'+X'0a',10,10);
8          -> '40'

• COS(X)

_X_의 코사인을 반환하며, _X_는 라디안으로 주어집니다. _X_가 NULL이면 NULL을 반환합니다.

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

• COT(X)

_X_의 코탄젠트를 반환합니다. _X_가 NULL이면 NULL을 반환합니다.

1mysql> SELECT COT(12);
2          -> -1.5726734063977
3mysql> SELECT COT(0);
4          -> out-of-range error

• CRC32(expr)

순환 중복 검사 값을 계산하여 32비트 unsigned 값을 반환합니다. 인자가 NULL이면 결과는 NULL입니다. 인자는 문자열일 것으로 기대되며, 그렇지 않은 경우에도 가능하면 문자열로 취급됩니다.

1mysql> SELECT CRC32('MySQL');
2          -> 3259397556
3mysql> SELECT CRC32('mysql');
4          -> 2501908538

• DEGREES(X)

인자 _X_를 라디안에서 도(degree)로 변환하여 반환합니다. _X_가 NULL이면 NULL을 반환합니다.

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

• EXP(X)

자연 로그의 밑인 _e_를 _X_의 지수 승으로 올린 값을 반환합니다. 이 함수의 역함수는 (인자를 하나만 사용할 때의) LOG() 또는 LN()입니다.

_X_가 NULL이면, 이 함수는 NULL을 반환합니다.

1mysql> SELECT EXP(2);
2          -> 7.3890560989307
3mysql> SELECT EXP(-2);
4          -> 0.13533528323661
5mysql> SELECT EXP(0);
6          -> 1

• FLOOR(X)

_X_보다 크지 않은 가장 큰 정수 값을 반환합니다. _X_가 NULL이면 NULL을 반환합니다.

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

정확값 숫자 인자의 경우, 반환 값은 정확값 숫자 타입입니다. 문자열 또는 부동 소수점 인자의 경우, 반환 값은 부동 소수점 타입입니다.

• FORMAT(X,D)

숫자 _X_를 '#,###,###.##'와 같은 형식으로, D 소수 자릿수까지 반올림하여 포매팅하고, 결과를 문자열로 반환합니다. 자세한 내용은 Section 14.8, “String Functions and Operators”를 참조하십시오.

• HEX(N_or_S)

이 함수는 10진수 숫자 또는 문자열의 16진수 표현을 얻는 데 사용할 수 있으며, 인자의 타입에 따라 동작 방식이 달라집니다. 자세한 내용은 Section 14.8, “String Functions and Operators”에 있는 이 함수 설명을 참조하십시오.

• LN(X)

_X_의 자연 로그, 즉 _X_의 밑-e 로그를 반환합니다. _X_가 0.0E0 이하이면, 함수는 NULL을 반환하고 “Invalid argument for logarithm”이라는 경고를 보고합니다. _X_가 NULL이면 NULL을 반환합니다.

1mysql> SELECT LN(2);
2          -> 0.69314718055995
3mysql> SELECT LN(-2);
4          -> NULL

이 함수는 LOG(X)와 동의어입니다. 이 함수의 역함수는 EXP() 함수입니다.

• LOG(X), LOG(B,X)

인자를 하나만 사용하여 호출하면, 이 함수는 _X_의 자연 로그를 반환합니다. _X_가 0.0E0 이하이면, 함수는 NULL을 반환하고 “Invalid argument for logarithm”이라는 경고를 보고합니다. X 또는 _B_가 NULL이면 NULL을 반환합니다.

(인자를 하나만 사용하여 호출될 때) 이 함수의 역함수는 EXP() 함수입니다.

1mysql> SELECT LOG(2);
2          -> 0.69314718055995
3mysql> SELECT LOG(-2);
4          -> NULL

인자를 두 개로 호출하면, 이 함수는 밑이 _B_인 _X_의 로그를 반환합니다. _X_가 0 이하이거나 _B_가 1 이하이면, NULL이 반환됩니다.

1mysql> SELECT LOG(2,65536);
2          -> 16
3mysql> SELECT LOG(10,100);
4          -> 2
5mysql> SELECT LOG(1,100);
6          -> NULL

LOG(B,X)는 LOG(X) / LOG(B)와 동일합니다.

• LOG2(X)

X의 밑-2 로그를 반환합니다. _X_가 0.0E0 이하이면, 함수는 NULL을 반환하고 “Invalid argument for logarithm”이라는 경고를 보고합니다. _X_가 NULL이면 NULL을 반환합니다.

1mysql> SELECT LOG2(65536);
2          -> 16
3mysql> SELECT LOG2(-100);
4          -> NULL

LOG2()는 숫자가 저장에 몇 비트가 필요한지를 알아내는 데 유용합니다. 이 함수는 다음 표현식과 거의 동일합니다: LOG(X) / LOG(2).

• LOG10(X)

_X_의 밑-10 로그를 반환합니다. _X_가 0.0E0 이하이면, 함수는 NULL을 반환하고 “Invalid argument for logarithm”이라는 경고를 보고합니다. _X_가 NULL이면 NULL을 반환합니다.

1mysql> SELECT LOG10(2);
2          -> 0.30102999566398
3mysql> SELECT LOG10(100);
4          -> 2
5mysql> SELECT LOG10(-100);
6          -> NULL

LOG10(X)는 LOG(10,X)와 거의 동일합니다.

• MOD(N,M), N % M, N MOD M

모듈로 연산입니다. _N_을 _M_으로 나눈 나머지를 반환합니다. M 또는 _N_이 NULL이면 NULL을 반환합니다.

1mysql> SELECT MOD(234, 10);
2          -> 4
3mysql> SELECT 253 % 7;
4          -> 1
5mysql> SELECT MOD(29,9);
6          -> 2
7mysql> SELECT 29 MOD 9;
8          -> 2

이 함수는 BIGINT 값에 대해 안전하게 사용할 수 있습니다.

MOD()는 소수 부분을 가진 값에 대해서도 동작하며, 나눗셈 이후의 정확한 나머지를 반환합니다:

1mysql> SELECT MOD(34.5,3);
2          -> 1.5

MOD(N,0)은 NULL을 반환합니다.

• PI()

π (pi) 값을 반환합니다. 표시되는 기본 소수 자릿수는 7자리이지만, 내부적으로는 MySQL이 전체 배정밀도 값을 사용합니다.

이 함수의 반환 값은 배정밀도 값이기 때문에, 그 정확한 표현은 플랫폼이나 구현에 따라 달라질 수 있습니다. 이는 PI()를 사용하는 어떠한 표현식에도 적용됩니다. Section 13.1.4, “Floating-Point Types (Approximate Value) - FLOAT, DOUBLE”를 참조하십시오.

1mysql> SELECT PI();
2          -> 3.141593
3mysql> SELECT PI()+0.000000000000000000;
4          -> 3.141592653589793000

• POW(X,Y)

_X_를 _Y_의 거듭제곱으로 올린 값을 반환합니다. X 또는 _Y_가 NULL이면 NULL을 반환합니다.

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

• POWER(X,Y)

이는 POW()의 동의어입니다.

• RADIANS(X)

인자 _X_를 도(degree)에서 라디안으로 변환하여 반환합니다. (π 라디안은 180도와 같다는 점에 유의하십시오.) _X_가 NULL이면 NULL을 반환합니다.

1mysql> SELECT RADIANS(90);
2          -> 1.5707963267949

• RAND([N])

범위 0 <= v < 1.0의 임의의 부동 소수점 값 _v_를 반환합니다. 범위 i <= R < _j_의 임의의 정수 _R_을 얻으려면 다음 표현식을 사용합니다: FLOOR(i + RAND() * (j − i)). 예를 들어, 범위 7 <= R < 12에서 임의의 정수를 얻으려면 다음 구문을 사용합니다:

1SELECT FLOOR(7 + (RAND() * 5));

정수 인자 _N_이 지정되면, 이는 시드 값으로 사용됩니다:

• 상수 초기화 인자를 사용하면, 시드는 구문이 실행되기 전에, 준비될 때 한 번만 초기화됩니다.

• 비상수 초기화 인자(예: 컬럼 이름)를 사용하면, 시드는 RAND()의 각 호출에 대해 해당 값으로 초기화됩니다.

이 동작의 한 귀결은 동일한 인자 값에 대해 RAND(N)이 매번 동일한 값을 반환하여, 컬럼 값의 반복 가능한 시퀀스를 생성한다는 점입니다. 다음 예에서는 RAND(3)이 사용된 두 위치에서 생성되는 값 시퀀스가 동일합니다.

1mysql> CREATE TABLE t (i INT);
2Query OK, 0 rows affected (0.42 sec)
3
4mysql> INSERT INTO t VALUES(1),(2),(3);
5Query OK, 3 rows affected (0.00 sec)
6Records: 3  Duplicates: 0  Warnings: 0
7
8mysql> SELECT i, RAND() FROM t;
9+------+------------------+
10| i    | RAND()           |
11+------+------------------+
12|    1 | 0.61914388706828 |
13|    2 | 0.93845168309142 |
14|    3 | 0.83482678498591 |
15+------+------------------+
163 rows in set (0.00 sec)
17
18mysql> SELECT i, RAND(3) FROM t;
19+------+------------------+
20| i    | RAND(3)          |
21+------+------------------+
22|    1 | 0.90576975597606 |
23|    2 | 0.37307905813035 |
24|    3 | 0.14808605345719 |
25+------+------------------+
263 rows in set (0.00 sec)
27
28mysql> SELECT i, RAND() FROM t;
29+------+------------------+
30| i    | RAND()           |
31+------+------------------+
32|    1 | 0.35877890638893 |
33|    2 | 0.28941420772058 |
34|    3 | 0.37073435016976 |
35+------+------------------+
363 rows in set (0.00 sec)
37
38mysql> SELECT i, RAND(3) FROM t;
39+------+------------------+
40| i    | RAND(3)          |
41+------+------------------+
42|    1 | 0.90576975597606 |
43|    2 | 0.37307905813035 |
44|    3 | 0.14808605345719 |
45+------+------------------+
463 rows in set (0.01 sec)

WHERE 절의 RAND()는 (하나의 테이블에서 선택할 때) 각 행 또는 (다중 테이블 조인에서 선택할 때) 행 조합마다 평가됩니다. 따라서 옵티마이저 관점에서 RAND()는 상수 값이 아니며, 인덱스 최적화를 위해 사용할 수 없습니다. 자세한 내용은 Section 10.2.1.20, “Function Call Optimization”을 참조하십시오.

ORDER BY 또는 GROUP BY 절에서 RAND() 값이 있는 컬럼을 사용하면 예상치 못한 결과가 나올 수 있습니다. 두 절 모두에 대해 RAND() 표현식은 동일한 행에 대해 여러 번 평가될 수 있는데, 이때마다 다른 결과를 반환할 수 있기 때문입니다. 행을 임의의 순서로 조회하는 것이 목적이라면 다음과 같은 구문을 사용할 수 있습니다:

1SELECT * FROM tbl_name ORDER BY RAND();

행 집합에서 임의의 샘플을 선택하려면, ORDER BY RAND()와 LIMIT를 결합합니다:

1SELECT * FROM table1, table2 WHERE a=b AND c<d ORDER BY RAND() LIMIT 1000;

RAND()는 완벽한 난수 생성기를 위한 것이 아닙니다. 이는 동일한 MySQL 버전에서는 플랫폼 간에 이식 가능한 방식으로, 필요할 때 빠르게 난수를 생성하는 수단입니다.

이 함수는 구문 기반 복제(statement-based replication)에 대해 안전하지 않습니다. binlog_format이 STATEMENT로 설정된 상태에서 이 함수를 사용하면 경고가 기록됩니다.

• ROUND(X), ROUND(X,D)

인자 _X_를 D 소수 자릿수까지 반올림합니다. 반올림 알고리즘은 _X_의 데이터 타입에 따라 달라집니다. _D_를 지정하지 않으면 기본값은 0입니다. _D_는 음수일 수 있으며, 이 경우 값 _X_의 소수점 왼쪽 D 자리 숫자가 0이 됩니다. _D_의 최대 절대값은 30이며, 30(또는 -30)을 넘는 자릿수는 잘립니다. X 또는 _D_가 NULL이면 함수는 NULL을 반환합니다.

1mysql> SELECT ROUND(-1.23);
2          -> -1
3mysql> SELECT ROUND(-1.58);
4          -> -2
5mysql> SELECT ROUND(1.58);
6          -> 2
7mysql> SELECT ROUND(1.298, 1);
8          -> 1.3
9mysql> SELECT ROUND(1.298, 0);
10          -> 1
11mysql> SELECT ROUND(23.298, -1);
12          -> 20
13mysql> SELECT ROUND(.12345678901234567890123456789012345, 35);
14          -> 0.123456789012345678901234567890

반환 값은 (첫 번째 인자가 정수, 배정밀도 또는 10진수라고 가정할 때) 첫 번째 인자와 동일한 타입을 가집니다. 이는 정수 인자에 대해 결과가 정수(소수 자릿수 없음)라는 뜻입니다:

1mysql> SELECT ROUND(150.000,2), ROUND(150,2);
2+------------------+--------------+
3| ROUND(150.000,2) | ROUND(150,2) |
4+------------------+--------------+
5|           150.00 |          150 |
6+------------------+--------------+

ROUND()는 첫 번째 인자의 타입에 따라 다음 규칙을 사용합니다:

• 정확값 숫자에 대해 ROUND()는 “0에서 멀어지는 반올림(round half away from zero)” 또는 “가장 가까운 쪽으로 반올림(round toward nearest)” 규칙을 사용합니다: 소수 부분이 .5 이상인 값은 양수일 때 다음 정수로 반올림되며, 음수일 때는 이전 정수로 반올림됩니다. (즉, 0에서 멀어지는 쪽으로 반올림됩니다.) 소수 부분이 .5 미만인 값은 양수일 때 이전 정수로, 음수일 때 다음 정수로 반올림됩니다.

• 근사값 숫자(approximate-value number)에 대해서는 결과가 C 라이브러리에 따라 달라집니다. 많은 시스템에서 이는 ROUND()가 “짝수 쪽으로 반올림(round to nearest even)” 규칙을 사용함을 의미합니다. 이 규칙에서 소수 부분이 두 정수의 중간값(.5)에 정확히 해당할 때는 가장 가까운 짝수 정수로 반올림됩니다.

다음 예는 정확값과 근사값에 대해 반올림이 어떻게 다른지를 보여줍니다:

1mysql> SELECT ROUND(2.5), ROUND(25E-1);
2+------------+--------------+
3| ROUND(2.5) | ROUND(25E-1) |
4+------------+--------------+
5| 3          |            2 |
6+------------+--------------+

자세한 내용은 Section 14.25, “Precision Math”를 참조하십시오.

ROUND() (및 TRUNCATE())에 의해 반환되는 데이터 타입은 다음에 나열된 규칙에 따라 결정됩니다:

• 첫 번째 인자가 어떤 정수 타입이든, 반환 타입은 항상 BIGINT입니다.

• 첫 번째 인자가 어떤 부동 소수점 타입이거나 어떤 비숫자 타입이면, 반환 타입은 항상 DOUBLE입니다.

• 첫 번째 인자가 DECIMAL 값이면, 반환 타입도 DECIMAL입니다.

• 반환 값의 타입 속성(type attribute)은 첫 번째 인자로부터 복사되지만, 두 번째 인자가 상수 값일 때의 DECIMAL은 예외입니다.

  원하는 소수 자릿수가 인자의 scale보다 작으면, 결과의 scale과 precision이 그에 맞게 조정됩니다.

  추가로, ROUND() (하지만 TRUNCATE() 함수는 아님)의 경우, 반올림으로 인해 유효 자릿수가 증가하는 것을 수용하기 위해 precision이 한 자리 확장됩니다. 두 번째 인자가 음수이면, 반환 타입은 scale이 0이 되도록 조정되며, precision도 그에 상응하게 조정됩니다. 예를 들어, ROUND(99.999, 2)는 100.00을 반환합니다. 첫 번째 인자는 DECIMAL(5, 3)이며, 반환 타입은 DECIMAL(5, 2)입니다.

  두 번째 인자가 음수이면, 반환 타입은 scale이 0이고 그에 상응하는 precision을 갖습니다; ROUND(99.999, -1)은 100을 반환하며, 이는 DECIMAL(3, 0)입니다.

• SIGN(X)

인자의 부호를 _X_가 음수, 0, 양수인 경우 각각 -1, 0, 1로 반환합니다. _X_가 NULL이면 NULL을 반환합니다.

1mysql> SELECT SIGN(-32);
2          -> -1
3mysql> SELECT SIGN(0);
4          -> 0
5mysql> SELECT SIGN(234);
6          -> 1

• SIN(X)

_X_의 사인을 반환하며, _X_는 라디안으로 주어집니다. _X_가 NULL이면 NULL을 반환합니다.

1mysql> SELECT SIN(PI());
2          -> 1.2246063538224e-16
3mysql> SELECT ROUND(SIN(PI()));
4          -> 0

• SQRT(X)

음수가 아닌 숫자 _X_의 제곱근을 반환합니다. _X_가 NULL이면 함수는 NULL을 반환합니다.

1mysql> SELECT SQRT(4);
2          -> 2
3mysql> SELECT SQRT(20);
4          -> 4.4721359549996
5mysql> SELECT SQRT(-16);
6          -> NULL

• TAN(X)

_X_의 탄젠트를 반환하며, _X_는 라디안으로 주어집니다. _X_가 NULL이면 NULL을 반환합니다.

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

• TRUNCATE(X,D)

숫자 _X_를 D 소수 자릿수까지 잘라서(truncate) 반환합니다. _D_가 0이면, 결과에는 소수점이나 소수 부분이 없습니다. _D_는 음수일 수 있으며, 이 경우 값 _X_의 소수점 왼쪽 D 자리 숫자가 0이 됩니다. X 또는 _D_가 NULL이면 함수는 NULL을 반환합니다.

1mysql> SELECT TRUNCATE(1.223,1);
2          -> 1.2
3mysql> SELECT TRUNCATE(1.999,1);
4          -> 1.9
5mysql> SELECT TRUNCATE(1.999,0);
6          -> 1
7mysql> SELECT TRUNCATE(-1.999,1);
8          -> -1.9
9mysql> SELECT TRUNCATE(122,-2);
10         -> 100
11mysql> SELECT TRUNCATE(10.28*100,0);
12         -> 1028

모든 숫자는 0을 향해 버림(truncate)됩니다.

TRUNCATE()가 반환하는 데이터 타입은 ROUND() 함수의 반환 타입을 결정하는 것과 동일한 규칙을 따릅니다. 자세한 내용은 ROUND()에 대한 설명을 참조하십시오.