- Chuyên mục khác :
- Git cơ bản và nâng cao
- ·
- MySQL cơ bản và nâng cao
- ·
- MongoDB cơ bản và nâng cao
- ·
- SQL cơ bản và nâng cao
- ·
- Linux cơ bản và nâng cao
- Cơ bản về SQL
- Học SQL cơ bản và nâng cao
- SQL là gì
- Các khái niệm RDBMS trong SQL
- RDBMS Database trong SQL
- Cú pháp SQL cơ bản
- Kiểu dữ liệu trong SQL
- Toán tử trong SQL
- Biểu thức trong SQL
- SQL Database
- Lệnh CREATE DATABASE trong SQL
- Lệnh DROP Database trong SQL
- Lệnh SELECT DATABASE trong SQL
- Lệnh RENAME DATABASE trong SQL
- SQL Table
- CREATE Table trong SQL - Tạo bảng trong SQL
- Lệnh DROP Table trong SQL
- DELETE trong SQL
- Lệnh RENAME Table trong SQL
- Lệnh TRUNCATE TABLE trong SQL
- Lệnh ALTER TABLE trong SQL
- Mô phỏng bảng trong SQL
- Bảng tạm (Temporary Table) trong SQL
- Nhóm lệnh thao tác cơ bản
- UPDATE trong SQL
- Truy vấn INSERT trong SQL
- Truy vấn SELECT trong SQL
- Mệnh đề ORDER BY trong SQL
- Mệnh đề GROUP BY trong SQL
- Từ khóa DISTINCT trong SQL
- Sắp xếp kết quả trong SQL
- Mệnh đề trong SQL
- Mệnh đề WHERE trong SQL
- Toán tử liên hợp AND và OR trong SQL
- Mệnh đề With trong SQL
- Mệnh đề LIKE trong SQL
- Mệnh đề TOP, LIMIT, ROWNUM trong SQL
- Hoạt động SQL nâng cao
- Mệnh đề UNION trong SQL
- Giá trị NULL trong SQL
- Alias trong SQL
- Chỉ mục (Index) trong SQL
- Sử dụng View trong SQL
- Mệnh đề HAVING trong SQL
- Transaction trong SQL
- Toán tử wildcard trong SQL
- Truy vấn con trong SQL
- Sử dụng Sequence trong SQL
- Xử lý bản sao trong SQL (DISTINCT)
- Injection trong SQL
- Ràng buộc trong SQL
- Ràng buộc (Constraint) trong SQL
- Ràng buộc NOT NULL trong SQL
- Ràng buộc DEFAULT trong SQL
- Ràng buộc UNIQUE trong SQL
- Ràng buộc PRIMARY KEY trong SQL
- Ràng buộc FOREIGN KEY trong SQL
- Ràng buộc CHECK trong SQL
- Ràng buộc INDEX trong SQL
- SQL Join
- Mệnh đề JOINS trong SQL
- INNER JOIN trong SQL
- LEFT JOIN trong SQL
- RIGHT JOIN trong SQL
- FULL JOIN trong SQL
- SELF JOIN trong SQL
- CARTESIAN JOIN hoặc CROSS JOIN trong SQL
- Hàm trong SQL
- Hàm hữu ích trong SQL
- Hàm xử lý Date và Time trong SQL
- Hàm xử lý số trong SQL
- Hàm xử lý chuỗi trong SQL
- Tài liệu SQL tham khảo
- First Normal Form (1NF) trong SQL
- Second Normal Form (2NF) trong SQL
- Third Normal Form (3NF) trong SQL
- Tuning DB trong SQL
- Tài liệu SQL tham khảo
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:
| Tên hàm | Miêu tả |
|---|---|
| Hàm ABS() | Trả về giá trị tuyệt đối của biểu thức số |
| Hàm ACOS() | Trả về arcos của biểu thức số. Hàm trả về NULL nếu giá trị không trong dãy -1 tới 1 |
| Hàm ASIN() | Trả về arcsin của biểu thức số. Hàm trả về NULL nếu giá trị không trong dãy -1 tới 1 |
| Hàm ATAN() | Trả về arctan của biểu thức số |
| Hàm ATAN2() | Trả về arctan của hai biến đã truyền cho nó |
| Hàm BIT_AND() | Trả về kết quả từ phép toán Bitwise AND trên tất cả bit trong biểu thức đã truyền |
| Hàm BIT_COUNT() | Trả về biểu diễn chuỗi của giá trị nhị phân đã truyền cho nó |
| Hàm BIT_OR() | Trả về kết quả từ phép toán Bitwise OR trên tất cả bit trong biểu thức đã truyền |
| Hàm CEIL() | Trả về giá trị nguyên nhỏ nhất mà không nhỏ hơn biểu thức số đã truyền |
| Hàm CEILING() | Trả về giá trị nguyên nhỏ nhất mà không nhỏ hơn biểu thức số đã truyền |
| Hàm CONV() | Chuyển đổi một biểu thức số từ một hệ cơ số sang hệ cơ số khác |
| Hàm COS() | Trả về cos của biểu thức số đã truyền. Biểu thức số nên được biểu diễn bằng giá trị radian |
| Hàm COT() | Trả về cotan của biểu thức số đã truyền |
| Hàm DEGREES() | Trả về biểu thức số đã được chuyển đổi từ radian sang độ |
| Hàm EXP() | Trả về giá trị hàm mũ với cơ số e |
| Hàm FLOOR() | Trả về giá trị nguyên lớn nhất mà không lớn hơn biểu thức số đã truyền |
| Hàm FORMAT() | Trả về biểu thức số đã được làm tròn về một số vị trí sau dấu phảy đã cho |
| Hàm GREATEST() | Trả về giá trị lớn nhất của các biểu thức input |
| Hàm INTERVAL() | Nhận các biểu thức exp1, exp2 và exp3, ... và trả về 0 nếu exp1 là nhỏ hơn exp2, trả về 1 nếu exp1 là nhỏ hơn exp3 và … |
| Hàm LEAST() | Trả về giá trị nhỏ nhất trong các biểu thức input đã nhập |
| Hàm LOG() | Trả về ln (loga nepe) của biểu thức số đã truyền |
| Hàm LOG10() | Trả về log10 của biểu thức số đã truyền |
| Hàm MOD() | Trả về phần dư của phép chia hai biểu thức số |
| Hàm OCT() | Trả về biểu diễn chuỗi của giá trị cơ số 8 của biểu thức số đã truyền. Trả về NULL nếu giá trị đã truyền là NULL |
| Hàm PI() | Trả về giá trị của PI |
| Hàm POW() | Trả về giá trị hàm mũ của hai số |
| Hàm POWER() | Trả về giá trị hàm mũ của hai số |
| Hàm RADIANS() | Trả về giá trị của biểu thức đã truyền sau khi đã chuyển đổi từ độ sang radian |
| Hàm ROUND() | Trả về biểu thức số đã được làm tròn về một số nguyên. Có thể được sử dụng để làm tròn một biểu thức số về vị trí sau dấu phảy nào đó |
| Hàm SIN() | Trả về sin của biểu thức số đã cho (được cung cấp với giá trị radian) |
| Hàm SQRT() | Trả về căn bậc hai của biểu thức số |
| Hàm STD() | Trả về độ lệch chuẩn (phương sai) của biểu thức số |
| Hàm STDDEV() | Trả về độ lệch chuẩn (phương sai) của biểu thức số |
| Hàm TAN() | Trả về tan của biểu thức số đã cho (được cung cấp với giá trị radian) |
| Hàm TRUNCATE() | Trả về biểu thức expr1 đã bị cắt về số vị trí sau dấu phảy cụ thể đã được xác định bởi expr2. Nếu expr2 là 0, thì kết quả sẽ không có dấu thập phân |
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)
Bình luận (0)