Hàm xử lý số trong SQL

được sử dụng để thao tác trên các số và thực hiện các phép tính số học. Bảng dưới liệt kê chi tiết các hàm xử lý số này:

Hàm ABS(X)

Hàm ABS() trả về giá trị tuyệt đối của X. Bạn theo dõi ví dụ sau:

SQL> SELECT ABS(2);
+---------------------------------------------------------+
| ABS(2)                                                  |
+---------------------------------------------------------+
| 2                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

SQL> SELECT ABS(-2);
+---------------------------------------------------------+
| ABS(2)                                                  |
+---------------------------------------------------------+
| 2                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Hàm ACOS(X)

Hàm này trả về arcos của X. Giá trị X phải nằm trong dãy giữa -1 và 1, nếu không NULL sẽ được trả về. Bạn theo dõi ví dụ sau:

SQL> SELECT ACOS(1);
+---------------------------------------------------------+
| ACOS(1)                                                 |
+---------------------------------------------------------+
| 0.000000                                                |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Hàm ASIN(X)

Hàm ASIN() trả về arcsin của X. Giá trị X phải nằm trong dãy giữa -1 và 1, nếu không NULL sẽ được trả về.

SQL> SELECT ASIN(1);
+---------------------------------------------------------+
| ASIN(1)                                                 |
+---------------------------------------------------------+
| 1.5707963267949                                         |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Hàm ATAN(X)

Hàm ATAN() trả về arctan của X.

SQL> SELECT ATAN(1);
+---------------------------------------------------------+
| ATAN(1)                                                 |
+---------------------------------------------------------+
| 0.78539816339745                                        |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Hàm ATAN2(Y,X)

Hàm này trả về arctan của hai tham số: X và Y. Nó là tương tự như arctan của Y/X, ngoại trừ góc của cả hai được sử dụng để tìm góc phần tư của kết quả.

SQL> SELECT ATAN2(3,6);
+---------------------------------------------------------+
| ATAN2(3,6)                                              |
+---------------------------------------------------------+
| 0.46364760900081                                        |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Hàm BIT_AND(bieu_thuc)

Hàm BIT_AND trả về Bitwise AND tất cả các bit trong bieu_thuc. Bitwise AND dựa trên: nếu hai bit tương ứng là giống nhau, thì một hoạt động Bitwise AND sẽ trả về 1, nếu khác nhau thì trả về 0. Hàm trả về một giá trị nguyên 64 bit. Nếu không có so khớp nào, thì nó trả về 18446744073709551615. Ví dụ sau sẽ thực hiện hàm BIT_AND trên cột PRICE đã được nhóm bởi MAKER (nhà sản xuất) của xe.

SQL> SELECT 
          MAKER, BIT_AND(PRICE) BITS
          FROM CARS GROUP BY MAKER
+---------------------------------------------------------+
|MAKER           BITS                                     |
+---------------------------------------------------------+
|CHRYSLER        512                                      |
|FORD            12488                                    |
|HONDA           2144                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Hàm BIT_COUNT(gia_tri_so)

Hàm BIT_COUNT() trả về số bit mà là active trong gia_tri_so. Ví dụ sau minh họa cách sử dụng của hàm này để trả về số active bit cho một dãy các số.

SQL> SELECT
          BIT_COUNT(2) AS TWO,
          BIT_COUNT(4) AS FOUR,
          BIT_COUNT(7) AS SEVEN
+-----+------+-------+
| TWO | FOUR | SEVEN |
+-----+------+-------+
|   1 |    1 |     3 |
+-----+------+-------+
1 row in set (0.00 sec)

Hàm BIT_OR(bieu_thuc)

Hàm BIT_OR() trả về Bitwise OR của tất cả các bit trong bieu_thuc. Bitwise OR dựa trên: nếu hai bit tương ứng là giống nhau thì trả về 0, ngược lại trả về 1. Hàm trả về số nguyên 64 bit. Ví dụ sau thực hiện hàm này trên cột PRICE của bảng CARS, đã được nhóm bởi MAKER.

SQL> SELECT 
          MAKER, BIT_OR(PRICE) BITS
          FROM CARS GROUP BY MAKER
+---------------------------------------------------------+
|MAKER           BITS                                     |
+---------------------------------------------------------+
|CHRYSLER        62293                                    |
|FORD            16127                                    |
|HONDA           32766                                    |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Hàm CEIL(X)

Hàm CEILING(X)

Các hàm này trả về giá trị nguyên nhỏ nhất mà không nhỏ hơn X. Bạn theo dõi ví dụ:

SQL> SELECT CEILING(3.46);
+---------------------------------------------------------+
| CEILING(3.46)                                           |
+---------------------------------------------------------+
| 4                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

SQL> SELECT CEIL(-6.43);
+---------------------------------------------------------+
| CEIL(-6.43)                                             |
+---------------------------------------------------------+
| -6                                                      |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Hàm CONV(N,tu_co_so,sang_co_so)

Mục đích của hàm CONV() là để chuyển đổi các số sang hệ cơ số khác. Hàm này trả về một chuỗi của N đã được chuyển đổi từ cơ số tu_co_so sang cơ số sang_co_so. Cơ số nhỏ nhất là 2 và lớn nhất là 36. Nếu bất kỳ tham số nào là NULL, thì hàm trả về NULL. Ví dụ sau sẽ chuyển đổi số 5 từ cơ số 16 sang cơ số 2.

SQL> SELECT CONV(5,16,2);
+---------------------------------------------------------+
| CONV(5,16,2)                                            |
+---------------------------------------------------------+
| 101                                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Hàm COS(X)

Hàm này trả về cos của X. Giá trị X được cung cấp với giá trị radian.

SQL>SELECT COS(90);
+---------------------------------------------------------+
| COS(90)                                                 |
+---------------------------------------------------------+
| -0.44807361612917                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Hàm COT(X)

Hàm này trả về cotan của X. Bạn theo dõi ví dụ sau:

SQL>SELECT COT(1);
+---------------------------------------------------------+
| COT(1)                                                  |
+---------------------------------------------------------+
| 0.64209261593433                                        |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Hàm DEGREES(X)

Hàm này trả về giá trị X sau khi đã được biến đổi từ radian sang độ.

SQL>SELECT DEGREES(PI());
+---------------------------------------------------------+
| DEGREES(PI())                                           |
+---------------------------------------------------------+
| 180.000000                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Hàm EXP(X)

Hàm này trả về giá trị của e mũ X.

SQL>SELECT EXP(3);
+---------------------------------------------------------+
| EXP(3)                                                  |
+---------------------------------------------------------+
| 20.085537                                               |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Hàm FLOOR(X)

Hàm này trả về giá trị nguyên lớn nhất mà không lớn hơn X.

SQL>SELECT FLOOR(7.55);
+---------------------------------------------------------+
| FLOOR(7.55)                                             |
+---------------------------------------------------------+
| 7                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Hàm FORMAT(X,D)

Hàm FORMAT() được sử dụng để định dạng X trong định dạng: ###,###,###.## đã được cắt D vị trí sau dấu phảy. Ví dụ sau minh họa cách sử dụng của hàm FORMAT().

SQL>SELECT FORMAT(423423234.65434453,2);
+---------------------------------------------------------+
| FORMAT(423423234.65434453,2)                            |
+---------------------------------------------------------+
| 423,423,234.65                                          |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Hàm GREATEST(n1,n2,n3,..........)

Hàm GREATEST() trả về giá trị lớn nhất trong tập hợp các tham số input là (n1, n2, n3, …). Ví dụ sau sử dụng hàm GREATEST() trả về số lớn nhất trong một tập hợp các biểu thức số.

SQL>SELECT GREATEST(3,5,1,8,33,99,34,55,67,43);
+---------------------------------------------------------+
| GREATEST(3,5,1,8,33,99,34,55,67,43)                     |
+---------------------------------------------------------+
| 99                                                      |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Hàm INTERVAL(N,N1,N2,N3,..........)

Hàm INTERVAL() so sánh giá trị N với các giá trị trong danh sách (N1, N2, N3, …). Hàm trả về 0 nếu N < N1, 1 nếu N < N2, 2 nếu N <N3, và .... Nó sẽ trả về -1 nếu N là NULL. Danh sách giá trị phải theo thứ tự N1 < N2 < N3 để làm việc hợp lý. Ví dụ sau minh họa cách hàm INTERVAL() làm việc.

SQL>SELECT INTERVAL(6,1,2,3,4,5,6,7,8,9,10);
+---------------------------------------------------------+
| INTERVAL(6,1,2,3,4,5,6,7,8,9,10)                        |
+---------------------------------------------------------+
| 6                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Hàm LEAST(N1,N2,N3,N4,......)

Hàm LEAST() là ngược với hàm GREATEST(). Mục đích của nó là trả về giá trị nhỏ nhất trong danh sách giá trị nhập vào (N1, N2, N3, N4, …). Ví dụ sau minh họa cách sử dụng của hàm này:

SQL>SELECT LEAST(3,5,1,8,33,99,34,55,67,43);
+---------------------------------------------------------+
| LEAST(3,5,1,8,33,99,34,55,67,43)                        |
+---------------------------------------------------------+
| 1                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Hàm LOG(X)

Hàm LOG(B,X)

Dạng hàm một tham số sẽ trả về ln (loga nepe) của X. Nếu hàm được gọi với hai tham số, nó trả về loga của X với một cơ số tùy ý B. Bạn theo dõi ví dụ:

SQL>SELECT LOG(45);
+---------------------------------------------------------+
| LOG(45)                                                 |
+---------------------------------------------------------+
| 3.806662                                                |
+---------------------------------------------------------+
1 row in set (0.00 sec)

SQL>SELECT LOG(2,65536);
+---------------------------------------------------------+
| LOG(2,65536)                                            |
+---------------------------------------------------------+
| 16.000000                                               |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Hàm LOG10(X)

Hàm này trả về log10(X).

SQL>SELECT LOG10(100);
+---------------------------------------------------------+
| LOG10(100)                                              |
+---------------------------------------------------------+
| 2.000000                                                |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Hàm MOD(N,M)

Hàm này trả về phần dư của phép chia N/M. Ví dụ:

SQL>SELECT MOD(29,3);
+---------------------------------------------------------+
| MOD(29,3)                                               |
+---------------------------------------------------------+
| 2                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Hàm OCT(N)

Hàm OCT() trả về biểu diễn chuỗi của số N trong hệ cơ số 8. Hàm này tương đương với hàm CONV(N,10,8).

SQL>SELECT OCT(12);
+---------------------------------------------------------+
| OCT(12)                                                 |
+---------------------------------------------------------+
| 14                                                      |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Hàm PI()

Hàm này trả về giá trị PI. Trong nội tại, SQL lưu giữ giá trị đầy đủ của PI.

SQL>SELECT PI();
+---------------------------------------------------------+
| PI()                                                    |
+---------------------------------------------------------+
| 3.141593                                                |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Hàm POW(X,Y)

Hàm POWER(X,Y)

Hai hàm này trả về giá trị X mũ Y.

SQL> SELECT POWER(3,3);
+---------------------------------------------------------+
| POWER(3,3)                                              |
+---------------------------------------------------------+
| 27                                                      |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Hàm RADIANS(X)

Hàm này trả về giá trị của X đã được chuyển đổi từ độ sang radian.

SQL>SELECT RADIANS(90);
+---------------------------------------------------------+
| RADIANS(90)                                             |
+---------------------------------------------------------+
|1.570796                                                 |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Hàm ROUND(X)

Hàm ROUND(X,D)

Hàm này trả về X được làm tròn về số nguyên gần nhất. Nếu cung cấp tham số thứ hai D, thì hàm này trả về X đã được làm tròn về vị trí sau dấu phảy đã được xác định bởi D. D phải là dương và tất cả chữ số còn lại ở bên phải của vị trí thập phân đã cho sẽ bị gỡ bỏ. Ví dụ:

SQL>SELECT ROUND(5.693893);
+---------------------------------------------------------+
| ROUND(5.693893)                                         |
+---------------------------------------------------------+
| 6                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

SQL>SELECT ROUND(5.693893,2);
+---------------------------------------------------------+
| ROUND(5.693893,2)                                       |
+---------------------------------------------------------+
| 5.69                                                    |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Hàm SIGN(X)

Hàm này trả về dấu của X, theo qui tắc: âm thì trả về -1, 0 trả về 0, và dương thì trả về 1.

SQL>SELECT SIGN(-4.65);
+---------------------------------------------------------+
| SIGN(-4.65)                                             |
+---------------------------------------------------------+
| -1                                                      |
+---------------------------------------------------------+
1 row in set (0.00 sec)

SQL>SELECT SIGN(0);
+---------------------------------------------------------+
| SIGN(0)                                                 |
+---------------------------------------------------------+
| 0                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

SQL>SELECT SIGN(4.65);
+---------------------------------------------------------+
| SIGN(4.65)                                              |
+---------------------------------------------------------+
| 1                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Hàm SIN(X)

Hàm này trả về sin(X). Ví dụ:

SQL>SELECT SIN(90);
+---------------------------------------------------------+
| SIN(90)                                                 |
+---------------------------------------------------------+
| 0.893997                                                |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Hàm SQRT(X)

Trả về căn bậc hai của số không âm X. Ví dụ:

SQL>SELECT SQRT(49);
+---------------------------------------------------------+
| SQRT(49)                                                |
+---------------------------------------------------------+
| 7                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Hàm STD(bieu_thuc)

Hàm STDDEV(bieu_thuc)

Hàm STD() được sử dụng để trả về độ lệch chuẩn (phương sai) của biểu thức. Hàm này tương đương với việc lấy căn bậc hai của hàm VARIANCE(bieu_thuc). Ví dụ sau tính độ lệch chuẩn của cột PRICE của bảng CARS.

SQL>SELECT STD(PRICE) STD_DEVIATION FROM CARS;
+---------------------------------------------------------+
| STD_DEVIATION                                           |
+---------------------------------------------------------+
| 7650.2146                                               |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Hàm TAN(X)

Hàm này trả về tan của tham số X, đã được biểu diễn trong radian.

SQL>SELECT TAN(45);
+---------------------------------------------------------+
| TAN(45)                                                 |
+---------------------------------------------------------+
| 1.619775                                                |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Hàm TRUNCATE(X,D)

Hàm này được sử dụng để trả về giá trị X sau khi đã cắt D vị trí sau dấu phảy. Nếu D là 0, thì dấu thập phân bị xóa. Nếu D là âm, thì phần nguyên của D xác định vị trí để cắt. Ví dụ:

SQL>SELECT TRUNCATE(7.536432,2);
+---------------------------------------------------------+
| TRUNCATE(7.536432,2)                                    |
+---------------------------------------------------------+
| 7.53                                                    |
+---------------------------------------------------------+
1 row in set (0.00 sec)