Xử Lý Date Trong SQL - Học Sql Cơ Bản đến Nâng Cao - VietTuts
Có thể bạn quan tâm
SQL cơ bản
SQL là gì? SQL - RDBMS là gì? SQL - Các hệ quản trị CSDL SQL - Cú pháp SQL - Kiểu dữ liệu SQL - Toán tử SQL - Biểu thức SQL - Create Database SQL - Drop Database SQL - Select Database SQL - Create Table SQL - Drop Table SQL - Câu lệnh Insert SQL - Câu lệnh Select SQL - Mệnh đề Where SQL - Toán tử AND & OR SQL - Câu lệnh Update SQL - Câu lệnh Delete SQL - Mệnh đề Like SQL - Mệnh đề Top SQL - Mệnh đề Order By SQL - Mệnh đề Group By SQL - Từ khóa DistinctSQL nâng cao
SQL - Các ràng buộc SQL - Mệnh đề JOIN SQL - INNER JOIN SQL - RIGHT JOIN SQL - LEFT JOIN SQL - FULL JOIN SQL - SELF JOIN SQL - Mệnh đề UNION SQL - Giá trị NULL SQL - Sử dụng Alias SQL - Sử dụng Index SQL - Lệnh Alter SQL - Lệnh Truncate Table SQL - Sử dụng View SQL - Mệnh đề Having SQL - Transaction SQL - Ký tự đại diện SQL - Các hàm xử lý Date SQL - Bảng tạm thời SQL - Clone Table SQL - Sub Querie SQL - Sequence SQL - Xử lý Duplicate Ký tự đại diện trong SQL Bảng tạm trong SQLBảng dưới đây liệt kê tất cả các hàm quan trọng trong danh sách các hàm xử lý Date trong SQL. Ngoài những hàm quan trong, có nhiều hàm khác được hỗ trợ bởi các RDBMS khác nhau. Danh sách đưa ra dựa trên MySQL RDBMS.
No. | Mô tả |
---|---|
1 | ADDDATE() Thêm ngày tháng |
2 | ADDTIME() Thêm thời gian |
3 | CONVERT_TZ() Chuyển đổi từ múi giờ này sang múi giờ khác |
4 | CURDATE() Trả về ngày hiện tại |
5 | CURRENT_DATE(), CURRENT_DATE Tương tự như hàm CURDATE() |
6 | CURRENT_TIME(), CURRENT_TIME Tương tự như hàm với CURTIME() |
7 | CURRENT_TIMESTAMP(), CURRENT_TIMESTAMP Tương tự như hàm với NOW() |
8 | CURTIME() Trả về thời gian hiện tại |
9 | DATE_ADD() Thêm hai ngày |
10 | DATE_FORMAT() Định dạng ngày theo quy định |
11 | DATE_SUB() Trừ hai ngày |
12 | DATE() Trả về phần ngày của date hoặc biểu thức datetime |
13 | DATEDIFF() Trừ hai ngày |
14 | DAY() Tương tự như DAYOFMONTH() |
15 | DAYNAME() Trả về tên của ngày trong tuần |
16 | DAYOFMONTH() Trả về ngày trong tháng (1-31) |
17 | DAYOFWEEK() Trả về chỉ số weekday của đối số |
18 | DAYOFYEAR() Trả về ngày trong năm (1-366) |
19 | EXTRACT Trả về một phần của một ngày |
20 | FROM_DAYS() Chuyển đổi một số ngày cho một ngày |
21 | FROM_UNIXTIME() Định dạng ngày như timestamp trên UNIX |
22 | HOUR() Trả về giờ từ đối số truyền vào |
23 | LAST_DAY Trả về ngày cuối cùng của tháng |
24 | LOCALTIME(), LOCALTIME Tương tự như hàm với NOW() |
25 | LOCALTIMESTAMP, LOCALTIMESTAMP() Tương tự như hàm với NOW() |
26 | MAKEDATE() Tạo một ngày từ năm và ngày trong năm |
27 | MAKETIME MAKETIME() |
28 | MICROSECOND() Trả về microseconds từ đối số |
29 | MINUTE() Trả về phút từ đối số |
30 | MONTH() Trả về tháng từ ngày được truyền vào |
31 | MONTHNAME() Trả về tên của tháng |
32 | NOW() Trả về ngày và giờ hiện tại |
33 | PERIOD_ADD() Thêm một khoảng thời gian cho một tháng một năm |
34 | PERIOD_DIFF() Trả về số tháng giữa các khoảng thời gian |
35 | QUARTER() Trả về quý từ đối số ngày |
36 | SEC_TO_TIME() Chuyển đổi giây sang định dạng 'HH: MM: SS' |
37 | SECOND() Trả về giá trị giây (0-59) |
38 | STR_TO_DATE() Chuyển đổi một chuỗi thành một ngày |
39 | SUBDATE() Khi được gọi với ba đối số, tương tự như hàm DATE_SUB() |
40 | SUBTIME() Trừ lần |
41 | SYSDATE() Trả về thời gian mà hàm thực thi |
42 | TIME_FORMAT() Định dạng theo thời gian |
43 | TIME_TO_SEC() Trả về đối số được chuyển đổi thành giây |
44 | TIME() Trả về phần thời gian từ đối số được truyền vào |
45 | TIMEDIFF() Trừ đi thời gian |
46 | TIMESTAMP() Với một đối số duy nhất, hàm này trả về ngày hoặc biểu thức datetime. Với hai đối số, tổng của các đối số |
47 | TIMESTAMPADD() Thêm khoảng thời gian vào một biểu thức datetime |
48 | TIMESTAMPDIFF() Loại trừ khoảng thời gian từ biểu thức datetime |
49 | TO_DAYS() Trả về đối số ngày được chuyển thành ngày |
50 | UNIX_TIMESTAMP() Trả về dấu thời gian UNIX |
51 | UTC_DATE() Trả về ngày giờ UTC hiện tại |
52 | UTC_TIME() Trả về thời gian UTC hiện tại |
53 | UTC_TIMESTAMP() Trả về ngày tháng hiện tại của UTC |
54 | WEEK() Trả về số tuần |
55 | WEEKDAY() Trả về chỉ số ngày trong tuần |
56 | WEEKOFYEAR() Trả về tuần dương lịch của ngày (1-53) |
57 | YEAR() Trả về năm |
58 | YEARWEEK() Trả về năm và tuần |
Nội dung chính
- ADDDATE (date, interval expr unit), ADDDATE (expr, ngày)
- ADDTIME (expr1, expr2)
- CONVERT_TZ (dt, from_tz, to_tz)
- CURDATE()
- CURRENT_DATE và CURRENT_DATE()
- CURTIME()
- CURRENT_TIME và CURRENT_TIME()
- CURRENT_TIMESTAMP và CURRENT_TIMESTAMP()
- DATE(expr)
- DATEDIFF (expr1, expr2)
- DATE_ADD(date,INTERVAL expr unit),
- DATE_FORMAT(date,format)
- DATE_SUB(date,INTERVAL expr unit)
- DAY(day)
- DAYNAME(date)
- DAYOFMONTH(date)
- DAYOFWEEK(date)
- DAYOFYEAR(date)
- EXTRACT(unit FROM date)
- FROM_DAYS(N)
- FROM_UNIXTIME(unix_timestamp)
- FROM_UNIXTIME(unix_timestamp, format)
- HOUR(time)
- LAST_DAY(day)
- LOCALTIME và LOCALTIME()
- LOCALTIMESTAMP và LOCALTIMESTAMP()
- MAKEDATE(year, dayofyear)
- MAKETIME(hour, minute, second)
- MICROSECOND(expr)
- MINUTE(time)
- MONTH(date)
- MONTHNAME(date)
- NOW()
- PERIOD_ADD(P, N)
- PERIOD_DIFF(P1, P2)
- QUARTER(day)
- SECOND(time)
- SEC_TO_TIME(seconds)
- STR_TO_DATE(str, format)
- SUBDATE(date, INTERVAL expr unit) và SUBDATE(expr, days)
- SUBTIME(expr1, expr2)
- SYSDATE()
- TIME(expr)
- TIMEDIFF(expr1, expr2)
- TIMESTAMP(expr),
- TIMESTAMP(expr1, expr2)
- TIMESTAMPADD(unit, interval, datetime_expr)
- TIMESTAMPDIFF(unit, datetime_expr1, datetime_expr2)
- TIME_FORMAT(time, format)
- TIME_TO_SEC(time)
- TO_DAYS(date)
- UNIX_TIMESTAMP(), UNIX_TIMESTAMP(date)
- UTC_DATE, UTC_DATE()
- UTC_TIME, UTC_TIME()
- UTC_TIMESTAMP, UTC_TIMESTAMP()
- WEEK(date, mode)
- WEEKDAY(date)
- WEEKOFYEAR(date)
- YEAR(date)
- YEARWEEK(date), YEARWEEK(date, mode)
ADDDATE (date, interval expr unit), ADDDATE (expr, ngày)
ADDDATE(date, interval expr unit)
Khi được gọi với dạng INTERVAL của đối số thứ hai, ADDDATE() tương tự như hàm DATE_ADD(). Còn hàm SUBDATE() tương tự như hàm DATE_SUB(). Để biết thông tin về đối số đơn vị INTERVAL, xem hàm DATE_ADD().
Ví dụ:
SELECT DATE_ADD('1998-01-02', INTERVAL 31 DAY);Kết quả:
+---------------------------------------------------------+ | DATE_ADD('1998-01-02', INTERVAL 31 DAY) | +---------------------------------------------------------+ | 1998-02-02 | +---------------------------------------------------------+ADDDATE(expr, days)
Khi được gọi với dạng ngày của đối số thứ hai, MySQL xử lý nó như là một số nguyên ngày được thêm vào biểu thức expr.
Ví dụ:
SELECT ADDDATE('1998-01-02', 31);Kết quả:
+---------------------------------------------------------+ | DATE_ADD('1998-01-02', INTERVAL 31 DAY) | +---------------------------------------------------------+ | 1998-02-02 | +---------------------------------------------------------+ADDTIME (expr1, expr2)
Hàm ADDTIME() trong SQL cộng giá trị expr2 vào expr1 và trả về kết quả. Expr1 là một biểu thức thời gian hoặc datetime, trong khi expr2 là một biểu thức time.
Ví dụ:
ELECT ADDTIME('1997-12-31 23:59:59.999999','1 1:1:1.000002');Kết quả
+---------------------------------------------------------+ | DATE_ADD('1997-12-31 23:59:59.999999','1 1:1:1.000002') | +---------------------------------------------------------+ | 1998-01-02 01:01:01.000001 | +---------------------------------------------------------+CONVERT_TZ (dt, from_tz, to_tz)
Hàm CONVERT_TZ() trong SQL được sử dụng để chuyển đổi giá trị dt từ từ múi giờ đã cho from_tz thành múi giờ to_tz và trả về kết quả. Hàm này trả về NULL nếu các đối số không hợp lệ.
Ví dụ:
SELECT CONVERT_TZ('2004-01-01 12:00:00','GMT','MET');Kết quả:
+---------------------------------------------------------+ | CONVERT_TZ('2004-01-01 12:00:00','GMT','MET') | +---------------------------------------------------------+ | 2004-01-01 13:00:00 | +---------------------------------------------------------+Ví dụ:
SELECT CONVERT_TZ('2004-01-01 12:00:00','+00:00','+10:00');Kết quả:
+---------------------------------------------------------+ | CONVERT_TZ('2004-01-01 12:00:00','+00:00','+10:00') | +---------------------------------------------------------+ | 2004-01-01 22:00:00 | +---------------------------------------------------------+CURDATE()
Hàm CURDATE() trong SQL trả về ngày hiện tại có định dạng 'YYYY-MM-DD' hoặc YYYYMMDD, tùy thuộc vào việc hàm được sử dụng trong ngữ cảnh trong một chuỗi hay một số.
Ví dụ:
SELECT CURDATE();Kết quả:
+---------------------------------------------------------+ | CURDATE() | +---------------------------------------------------------+ | 1997-12-15 | +---------------------------------------------------------+Ví dụ:
SELECT CURDATE() + 0;Kết quả:
+---------------------------------------------------------+ | CURDATE() + 0 | +---------------------------------------------------------+ | 19971215 | +---------------------------------------------------------+CURRENT_DATE và CURRENT_DATE()
CURRENT_DATE và CURRENT_DATE() là những hàm có chức năng tương tự như hàm CURDATE()
CURTIME()
Hàm CURTIME() trong SQL trả về thời gian hiện tại dưới dạng giá trị 'HH: MM: SS' hoặc HHMMSS, tùy thuộc vào việc hàm được sử dụng trong ngữ cảnh một chuỗi hay một số. Giá trị được thể hiện trong múi giờ hiện tại.
Ví dụ:
SELECT CURTIME();Kết quả:
+---------------------------------------------------------+ | CURTIME() | +---------------------------------------------------------+ | 23:50:26 | +---------------------------------------------------------+Ví dụ:
SELECT CURTIME(); SELECT CURTIME() + 0;Kết quả:
+---------------------------------------------------------+ | CURTIME() + 0 | +---------------------------------------------------------+ | 235026 | +---------------------------------------------------------+CURRENT_TIME và CURRENT_TIME()
CURRENT_TIME và CURRENT_TIME() là những hàm có chức năng tương tự như hàm CURTIME().
CURRENT_TIMESTAMP và CURRENT_TIMESTAMP()
CURRENT_TIMESTAMP và CURRENT_TIMESTAMP() là những hàm có chức năng tương tự như hàm NOW().
DATE(expr)
Hàm DATE() trong SQL trả về phần ngày của date hoặc biểu thức expr.
Ví dụ:
SELECT DATE('2017-12-31 01:02:03');Kết quả:
+---------------------------------------------------------+ | DATE('2017-12-31 01:02:03') | +---------------------------------------------------------+ | 2003-12-31 | +---------------------------------------------------------+DATEDIFF (expr1, expr2)
Hàm DATEDIFF() trong SQL trả về phần ngày của expr1 trừ đi phần ngày của expr2. Cả hai expr1 và expr2 là ngày hoặc các biểu thức ngày và giờ. Chỉ tính phần ngày của các giá trị được sử dụng trong tính toán.
Ví dụ:
SELECT DATEDIFF('2017-12-31 23:59:59','2017-12-20');Kết quả:
+---------------------------------------------------------+ | DATEDIFF('2017-12-31 23:59:59','2017-12-20') | +---------------------------------------------------------+ | 11 | +---------------------------------------------------------+ 1 row in set (0.0001)DATE_ADD(date,INTERVAL expr unit),
Hàm DATE_ADD() và DATE_SUB() trong được sử dụng để tính toán ngày. Tham số date là một giá trị DATETIME hoặc DATE xác định ngày bắt đầu. Tham số expr là một biểu thức xác định giá trị INTERVAL để được thêm vào hoặc trừ từ ngày bắt đầu. Các expr là một chuỗi; Nó có thể bắt đầu với dấu '-' cho các khoảng âm.
Một unit là một từ khóa cho biết các đơn vị mà trong đó biểu thức nên được diễn giải.
Từ khóa INTERVAL và giá trị unit không phân biệt chữ hoa.
Bảng dưới đây cho thấy định dạng dự kiến của đối số expr cho mỗi giá trị unit.
Giá trị unit | Định dạng dự kiến |
---|---|
MICROSECOND | MICROSECONDS |
SECOND | SECONDS |
MINUTE | MINUTES |
HOUR | HOURS |
DAY | DAYS |
WEEK | WEEKS |
MONTH | MONTHS |
QUARTER | QUARTERS |
YEAR | YEARS |
SECOND_MICROSECOND | 'SECONDS.MICROSECONDS' |
MINUTE_MICROSECOND | 'MINUTES.MICROSECONDS' |
MINUTE_SECOND | 'MINUTES:SECONDS' |
HOUR_MICROSECOND | 'HOURS.MICROSECONDS' |
HOUR_SECOND | 'HOURS:MINUTES:SECONDS' |
HOUR_MINUTE | 'HOURS:MINUTES' |
DAY_MICROSECOND | 'DAYS.MICROSECONDS' |
DAY_SECOND | 'DAYS HOURS:MINUTES:SECONDS' |
DAY_MINUTE | 'DAYS HOURS:MINUTES' |
DAY_HOUR | 'DAYS HOURS' |
YEAR_MONTH | 'YEARS-MONTHS' |
Các giá trị QUARTER và WEEK có sẵn từ MySQL 5.0.0. phiên bản.
Ví dụ:
Ví dụ:
SELECT DATE_ADD('1997-12-31 23:59:59', INTERVAL '1:1' MINUTE_SECOND);Kết quả:
+---------------------------------------------------------+ | DATE_ADD('1997-12-31 23:59:59', INTERVAL... | +---------------------------------------------------------+ | 1998-01-01 00:01:00 | +---------------------------------------------------------+Ví dụ 2:
Ví dụ:
SELECT DATE_ADD('1999-01-01', INTERVAL 1 HOUR);Kết quả:
+---------------------------------------------------------+ | DATE_ADD('1999-01-01', INTERVAL 1 HOUR) | +---------------------------------------------------------+ | 1999-01-01 01:00:00 | +---------------------------------------------------------+DATE_FORMAT(date,format)
Hàm DATE_FORMAT() trong SQL được sử dụng để định dạng giá trị date theo chuỗi định dạng.
Các specifier sau có thể được sử dụng trong chuỗi định dạng. Ký tự '%' là bắt buộc trước các ký tự định nghĩa định dạng.
No. | Specifier và Mô tả |
---|---|
1 | %a Tên ngày trong tuần viết tắt (Sun..Sat) |
2 | %b Tên tháng viết tắt (Jan.Dec) |
3 | %c Tháng, số (0..12) |
4 | %D Ngày tháng có hậu tố tiếng Anh (0th, 1st, 2nd, 3rd,...) |
5 | %d Ngày trong tháng, số (00..31) |
6 | %e Ngày trong tháng, số (0..31) |
7 | %f Microseconds (000000..999999) |
số 8 | %H Giờ (00..23) |
9 | %h Giờ (01..12) |
số 10 | %I Giờ (01..12) |
11 | %i Số phút, số (00..59) |
12 | %j Ngày trong năm (001..366) |
13 | %k Giờ (0..23) |
14 | %l Giờ (1..12) |
15 | %M Tên tháng (January..December) |
16 | %m Tháng, số (00..12) |
17 | %p AM hoặc PM |
18 | %r Thời gian, 12 giờ (hh:mm:ss theo sau là AM hoặc PM) |
19 | %S Giây (00..59) |
20 | %s Giây (00..59) |
21 | %T Thời gian, 24 giờ (hh: mm: ss) |
22 | %U Tuần (00..53), trong đó chủ nhật là ngày đầu tiên trong tuần |
23 | %u Tuần (00..53), thứ hai là ngày đầu tiên trong tuần |
24 | %V Tuần lễ (01..53), chủ nhật là ngày đầu tiên trong tuần; Được sử dụng với %X |
25 | %v Tuần (01..53), thứ hai là ngày đầu tiên trong tuần; Được sử dụng với %x |
26 | %W Tên ngày trong tuần (Sunday..Saturday) |
27 | %w Ngày trong tuần (0=Sunday..6=Saturday) |
28 | %X Năm cho tuần Chủ Nhật là ngày đầu tiên của tuần, số, bốn chữ số; Được sử dụng với %V |
29 | %x Năm cho tuần, thứ hai là ngày đầu tiên của tuần, số, bốn chữ số; Được sử dụng với %v |
30 | %Y Năm với bốn chữ số |
31 | %y Năm với hai chữ số |
32 | %% Một chữ .%. ký tự |
33 | %x Đối với bất kỳ .x. không được liệt kê ở trên |
Ví dụ:
Ví dụ:
SELECT DATE_FORMAT('2017-10-04 22:23:00', '%W %M %Y');Kết quả:
+---------------------------------------------------------+ | DATE_FORMAT('2017-10-04 22:23:00', '%W %M %Y') | +---------------------------------------------------------+ | Wednesday October 2017 | +---------------------------------------------------------+Ví dụ 2:
Ví dụ:
SELECT DATE_FORMAT('1997-10-04 22:23:00', '%H %k %I %r %T %S %w');Kết quả:
+-------------------------------------------------------------+ | DATE_FORMAT('1997-10-04 22:23:00', '%H %k %I %r %T %S %w') | +-------------------------------------------------------------+ | 22 22 10 10:23:00 PM 22:23:00 00 6 | +-------------------------------------------------------------+DATE_SUB(date,INTERVAL expr unit)
Hàm DATE_SUB() trong SQL tương tự như chức năng DATE_ADD().
DAY(day)
Hàm DAY() trong SQL tương tự như DAYOFMONTH().
DAYNAME(date)
Hàm DAYNAME() trong SQL trả về tên của ngày trong tuần từ date đã cho.
Ví dụ:
SELECT DAYNAME('1998-02-05');Kết quả:
+---------------------------------------------------------+ | DAYNAME('1998-02-05') | +---------------------------------------------------------+ | Thursday | +---------------------------------------------------------+DAYOFMONTH(date)
Hàm DAYOFMONTH() trong SQL trả về ngày trong tháng từ date đã cho, trong khoảng từ 0 đến 31.
Ví dụ:
SELECT DAYOFMONTH('1998-02-03');Kết quả:
+---------------------------------------------------------+ | DAYOFMONTH('1998-02-03') | +---------------------------------------------------------+ | 3 | +---------------------------------------------------------+DAYOFWEEK(date)
Hàm DAYOFWEEK() trong SQL trả về chỉ số tuần trong ngày (1 = Sunday, 2 = Monday, ., 7 = Saturday). Các giá trị chỉ số này tương ứng với tiêu chuẩn ODBC.
Ví dụ:
SELECT DAYOFWEEK('1998-02-03');Kết quả:
+---------------------------------------------------------+ |DAYOFWEEK('1998-02-03') | +---------------------------------------------------------+ | 3 | +---------------------------------------------------------+DAYOFYEAR(date)
Hàm DAYOFYEAR() trong SQL trả về ngày trong năm cho ngày, trong khoảng từ 1 đến 366.
Ví dụ:
SELECT DAYOFYEAR('1998-02-03');Kết quả:
+---------------------------------------------------------+ | DAYOFYEAR('1998-02-03') | +---------------------------------------------------------+ | 34 | +---------------------------------------------------------+EXTRACT(unit FROM date)
Hàm EXTRACT() trong SQL sử dụng cùng một kiểu unit định dạng như DATE_ADD() hoặc DATE_SUB(), nhưng lấy ra phần từ ngày chứ không phải là thêm hay trừ datetime.
Ví dụ 1:
SELECT EXTRACT(YEAR FROM '1999-07-02');Kết quả:
+---------------------------------------------------------+ | EXTRACT(YEAR FROM '1999-07-02') | +---------------------------------------------------------+ | 1999 | +---------------------------------------------------------+Ví dụ 2:
SELECT EXTRACT(YEAR_MONTH FROM '1999-07-02 01:02:03');Kết quả:
+---------------------------------------------------------+ | EXTRACT(YEAR_MONTH FROM '1999-07-02 01:02:03') | +---------------------------------------------------------+ | 199907 | +---------------------------------------------------------+FROM_DAYS(N)
Hàm FROM_DAYS() trong SQL được sử dụng để chuyển đổi số N thành một giá trị date cụ thể.
Ví dụ:
SELECT FROM_DAYS(729669);Kết quả:
+---------------------------------------------------------+ | FROM_DAYS(729669) | +---------------------------------------------------------+ | 1997-10-07 | +---------------------------------------------------------+ Lưu ý - Sử dụng FROM_DAYS() cẩn thận với ngày cũ. Nó không được sử dụng với các giá trị mà trước khi sự ra đời của lịch Gregorian (1582).FROM_UNIXTIME(unix_timestamp)
FROM_UNIXTIME(unix_timestamp, format)
Hàm FROM_UNIXTIME() trong SQL trả về đại diện của đối số unix_timestamp là một giá trị trong định dạng 'YYYY-MM-DD HH: MM: SS hoặc YYYYMMDHHMMSS, tùy thuộc vào việc hàm được sử dụng trong ngữ cảnh một chuỗi hay một số. Giá trị được thể hiện trong múi giờ hiện tại. Đối số unix_timestamp là một giá trị timestamp nội bộ, được tạo ra bởi hàm UNIX_TIMESTAMP() .
Nếu format được đưa ra, kết quả sẽ được định dạng theo chuỗi format, được sử dụng theo cách tương tự như được liệt kê trong mục nhập cho hàm DATE_FORMAT() .
Ví dụ:
SELECT FROM_UNIXTIME(875996580);Kết quả:
+---------------------------------------------------------+ | FROM_UNIXTIME(875996580) | +---------------------------------------------------------+ | 1997-10-04 22:23:00 | +---------------------------------------------------------+HOUR(time)
Hàm HOUR() trong SQL trả về giờ từ time đã cho. Phạm vi của giá trị trả về từ 0 đến 23 cho các giá trị thời gian trong ngày. Tuy nhiên, phạm vi của giá trị TIME thực sự lớn hơn nhiều, vì vậy HOUR có thể trả về giá trị lớn hơn 23.
Ví dụ:
SELECT HOUR('10:05:03');Kết quả:
+---------------------------------------------------------+ | HOUR('10:05:03') | +---------------------------------------------------------+ | 10 | +---------------------------------------------------------+LAST_DAY(day)
Hàm LAST_DAY() trong SQL có tham số truyền vào là giá trị ngày hoặc giá trị datetime và trả về giá trị tương ứng cho ngày cuối cùng của tháng. Trả về NULL nếu đối số không hợp lệ.
Ví dụ:
SELECT LAST_DAY('2003-02-05');Kết quả:
+---------------------------------------------------------+ | LAST_DAY('2003-02-05') | +---------------------------------------------------------+ | 2003-02-28 | +---------------------------------------------------------+LOCALTIME và LOCALTIME()
LOCALTIME và LOCALTIME() trong SQL là những hàm có chức năng tương tự hàm NOW().
LOCALTIMESTAMP và LOCALTIMESTAMP()
LOCALTIMESTAMP và LOCALTIMESTAMP() trong SQL là những hàm có chức năng tương tự hàm NOW().
MAKEDATE(year, dayofyear)
Hàm MAKEDATE() trong SQL trả về một ngày với tham số year và dayofyear. Giá trị dayofyear phải lớn hơn 0 nếu không kết quả sẽ là NULL.
Ví dụ:
SELECT MAKEDATE(2001,31), MAKEDATE(2001,32);Kết quả:
+---------------------------------------------------------+ | MAKEDATE(2001,31), MAKEDATE(2001,32) | +---------------------------------------------------------+ | '2001-01-31', '2001-02-01' | +---------------------------------------------------------+MAKETIME(hour, minute, second)
Hàm MAKETIME() trong SQL trả về giá trị time được tính từ các giá trị tham số hour, minute, second.
Ví dụ:
SELECT MAKETIME(12,15,30);Kết quả:
+---------------------------------------------------------+ | MAKETIME(12,15,30) | +---------------------------------------------------------+ | '12:15:30' | +---------------------------------------------------------+MICROSECOND(expr)
Hàm MICROSECOND() trong SQL trả về microseconds từ biểu thức time hoặc biểu thức thời gian (expr) dưới dạng số trong khoảng từ 0 đến 999999.
Ví dụ:
SELECT MICROSECOND('12:00:00.123456');Kết quả:
+---------------------------------------------------------+ | MICROSECOND('12:00:00.123456') | +---------------------------------------------------------+ | 123456 | +---------------------------------------------------------+MINUTE(time)
Hàm MINUTE() trong SQL trả về giá trị phút cho từ time đã cho, trong khoảng từ 0 đến 59.
Ví dụ:
SELECT MINUTE('98-02-03 10:05:03');Kết quả:
+---------------------------------------------------------+ | MINUTE('98-02-03 10:05:03') | +---------------------------------------------------------+ | 5 | +---------------------------------------------------------+MONTH(date)
Hàm MONTH() trong SQL trả về tháng từ date đã cho, trong khoảng từ 0 đến 12.
Ví dụ:
SELECT MONTH('1998-02-03');Kết quả:
+---------------------------------------------------------+ | MONTH('1998-02-03') | +---------------------------------------------------------+ | 2 | +---------------------------------------------------------+MONTHNAME(date)
Hàm MONTHNAME() trong SQL trả về tên đầy đủ của tháng từ date đã cho.
Ví dụ:
SELECT MONTHNAME('2017-02-02');Kết quả:
+---------------------------------------------------------+ | MONTHNAME('2017-02-02') | +---------------------------------------------------------+ | February | +---------------------------------------------------------+NOW()
Hàm NOW() trong SQL trả về datetime hiện tại dưới dạng một giá trị trong định dạng 'YYYY-MM-DD HH: MM: SS' hoặc YYYYMMDHHMMSS, tùy thuộc vào việc hàm được sử dụng trong một chuỗi hoặc ngữ cảnh số. Giá trị này được thể hiện trong múi giờ hiện tại.
Ví dụ:
SELECT NOW();Kết quả:
+---------------------------------------------------------+ | NOW() | +---------------------------------------------------------+ | 2017-07-07 07:17:17 | +---------------------------------------------------------+PERIOD_ADD(P, N)
Hàm PERIOD_ADD() trong SQL được sử dụng để thêm N tháng đến một khoảng thời gian P (theo định dạng YYMM hoặc YYYYMM). Trả về giá trị theo định dạng YYYYMM. Lưu ý rằng đối số khoảng P không phải là một giá trị ngày tháng.
Ví dụ:
SELECT PERIOD_ADD(9801, 2);Kết quả:
+---------------------------------------------------------+ | PERIOD_ADD(9801, 2) | +---------------------------------------------------------+ | 199803 | +---------------------------------------------------------+PERIOD_DIFF(P1, P2)
Hàm PERIOD_DIFF() trong SQL trả về số tháng giữa các khoảng thời gian P1 và P2. Các khoảng thời gian P1 và P2 phải ở định dạng YYMM hoặc YYYYMM. Lưu ý rằng đối số P1 và P2 không phải là giá trị ngày.
Ví dụ:
SELECT PERIOD_DIFF(9802,199703);Kết quả:
+---------------------------------------------------------+ | PERIOD_DIFF(9802,199703) | +---------------------------------------------------------+ | 11 | +---------------------------------------------------------+QUARTER(day)
Hàm QUARTER() trong SQL trả về quý trong năm từ ngày đã cho, trong khoảng từ 1 đến 4.
Ví dụ:
SELECT QUARTER('98-04-01');Kết quả:
+---------------------------------------------------------+ | QUARTER('98-04-01') | +---------------------------------------------------------+ | 2 | +---------------------------------------------------------+SECOND(time)
Hàm SECOND() trong SQL trả về giá trị giây từ time đã cho, trong khoảng từ 0 đến 59.
Ví dụ:
SELECT SECOND('10:15:20');Kết quả:
+-----------------------------------------+ | SECOND('10:15:20') | +-----------------------------------------+ | 20 | +-----------------------------------------+SEC_TO_TIME(seconds)
Hàm SEC_TO_TIME() trong SQL trả về giá trị được chuyển đổi từ giây đã cho thành giờ, phút và giây có định dạng 'HH: MM: SS' hoặc định dạng HHMMSS, tuỳ thuộc vào việc hàm này được sử dụng trong một chuỗi hoặc ngữ cảnh số.
Ví dụ:
SELECT SEC_TO_TIME(1001);Kết quả:
+---------------------------------------------------------+ | SEC_TO_TIME(1001) | +---------------------------------------------------------+ | 00:16:41 | +---------------------------------------------------------+STR_TO_DATE(str, format)
Hàm STR_TO_DATE() trong SQL là nghịch đảo của hàm DATE_FORMAT(). Tham số bao gồm chuỗi str và một chuỗi định dạng format. Hàm STR_TO_DATE() trả về giá trị DATETIME nếu chuỗi định dạng chứa cả phần DATE và TIME. Nếu khác, nó trả về giá trị DATE hoặc TIME nếu chuỗi chỉ chứa các phần DATE hoặc TIME.
Ví dụ:
SELECT STR_TO_DATE('04/31/2004', '%m/%d/%Y');Kết quả:
+---------------------------------------------------------+ | STR_TO_DATE('04/31/2004', '%m/%d/%Y') | +---------------------------------------------------------+ | 2004-04-31 | +---------------------------------------------------------+SUBDATE(date, INTERVAL expr unit) và SUBDATE(expr, days)
Khi được gọi với dạng INTERVAL của đối số thứ hai. Hàm SUBDATE() trong SQL là một hàm có chức năng giống hàm DATE_SUB().
Ví dụ:
SELECT SUBDATE('2017-07-12', INTERVAL 31 DAY);Kết quả:
+---------------------------------------------------------+ | SUBDATE('2017-07-12', INTERVAL 31 DAY) | +---------------------------------------------------------+ | 2017-06-11 | +---------------------------------------------------------+SUBTIME(expr1, expr2)
Hàm SUBTIME() trong SQL trả về giá trị time là hiệu của expr1 trừ expr2. Giá trị expr1 là time hoặc một biểu thức datetime, trong khi giá trị expr2 là một biểu thức time.
Ví dụ:
SELECT SUBTIME('2017-12-31 23:59:59.999999', '1 1:1:1.000002');Kết quả:
+---------------------------------------------------------+ | SUBTIME('2017-12-31 23:59:59.999999'... | +---------------------------------------------------------+ | 2017-12-30 22:58:58.999997 | +---------------------------------------------------------+SYSDATE()
Hàm SYSDATE() trong SQL trả về ngày hiện tại và thời gian dưới dạng một giá trị trong định dạng 'YYYY-MM-DD HH: MM: SS' hoặc YYYYMMDHHMMSS, tùy thuộc vào việc hàm được sử dụng trong một chuỗi hoặc trong một ngữ cảnh số.
Ví dụ:
SELECT SYSDATE();Kết quả:
+---------------------------------------------------------+ | SYSDATE() | +---------------------------------------------------------+ | 2006-04-12 13:47:44 | +---------------------------------------------------------+TIME(expr)
Hàm TIME() trong SQL trả về giá trị thời gian của một time hoặc expr biểu thức datetime đã cho và giá trị trả về là một chuỗi.
Ví dụ:
SELECT TIME('2003-12-31 01:02:03');Kết quả:
+---------------------------------------------------------+ | TIME('2003-12-31 01:02:03') | +---------------------------------------------------------+ | 01:02:03 | +---------------------------------------------------------+TIMEDIFF(expr1, expr2)
Hàm TIMEDIFF() trong SQL trả về thời gian khác nhau giữa 2 biểu thức thời gian đã cho expr1 và expr2. Các giá trị expr1 và expr2 là các biểu thức time hoặc datetime, nhưng cả hai đều phải có cùng kiểu.
Ví dụ:
SELECT TIMEDIFF('2017-12-31 23:59:59.000001', '2017-12-30 01:01:01.000002');Kết quả:
+---------------------------------------------------------+ | TIMEDIFF('2017-12-31 23:59:59.000001'..... | +---------------------------------------------------------+ | 46:58:57.999999 | +---------------------------------------------------------+TIMESTAMP(expr),
TIMESTAMP(expr1, expr2)
Hàm TIMESTAMP() trong SQL có 2 dạng. Với một đối số duy nhất, hàm này trả về biểu thức datetime với đối số expr có thể là date hoặc datetime. Với hai đối số, nó cộng thêm thời gian từ biểu thức expr2 đến date hoặc datetime của expr1 và trả về kết quả như một giá trị datetime.
Ví dụ:
SELECT TIMESTAMP('2017-12-31');Kết quả:
+---------------------------------------------------------+ | TIMESTAMP('2017-12-31') | +---------------------------------------------------------+ | 2017-12-31 00:00:00 | +---------------------------------------------------------+TIMESTAMPADD(unit, interval, datetime_expr)
Hàm TIMESTAMPADD() trong SQL được sử dụng để thêm một khoảng thời gian (interval) vào biểu thức date hoặc datetime datetime_expr. Đơn vị (unit) cho khoảng thời gian được cho bởi các đối số unit. Đối số unit nên là một trong những giá trị sau đây:
- FRAC_SECOND
- SECOND, MINUTE
- HOUR, DAY
- WEEK
- MONTH
- QUARTER
- YEAR
Giá trị unit có thể được chỉ định bằng cách sử dụng một trong các từ khoá được hiển thị hoặc với tiền tố của SQL_TSI_.
Ví dụ: DAY và SQL_TSI_DAY như vậy cũng là hợp lệ.
Ví dụ:
SELECT TIMESTAMPADD(MINUTE,1,'2017-01-02');Kết quả:
+---------------------------------------------------------+ | TIMESTAMPADD(MINUTE,1,'2017-01-02') | +---------------------------------------------------------+ | 2017-01-02 00:01:00 | +---------------------------------------------------------+TIMESTAMPDIFF(unit, datetime_expr1, datetime_expr2)
Hàm TIMESTAMPDIFF() trong SQL trả về một số nguyên thể hiện sự khác nhau giữa hai biểu thức date hoặc datetime (datetime_expr1 và datetime_expr2). Tham số unit được sử dụng để định nghĩa đơn vị của giá trị được trả về. Các giá trị hợp lệ cho unit giống như các giá trị được liệt kê trong mô tả của hàm TIMESTAMPADD().
Ví dụ:
SELECT TIMESTAMPDIFF(MONTH,'2017-02-01','2017-05-01');Kết quả:
+---------------------------------------------------------+ | TIMESTAMPDIFF(MONTH,'2017-02-01','2017-05-01') | +---------------------------------------------------------+ | 3 | +---------------------------------------------------------+TIME_FORMAT(time, format)
Hàm TIME_FORMAT trong SQL được sử dụng như hàm DATE_FORMAT(), nhưng chuỗi định dạng (format) có thể chỉ chứa định dạng trong giờ, phút và giây.
Nếu giá trị time chứa một phần giờ cao hơn 23, thì các định dạng định dạng %H và %k cho một giá trị lớn hơn phạm vi thông thường từ 0 đến 23. Các định dạng giờ khác tạo ra giá trị giờ theo kiểu 12 giờ.
Ví dụ:
SELECT TIME_FORMAT('100:00:00', '%H %k %h %I %l');Kết quả:
+---------------------------------------------------------+ | TIME_FORMAT('100:00:00', '%H %k %h %I %l') | +---------------------------------------------------------+ | 100 100 04 04 4 | +---------------------------------------------------------+TIME_TO_SEC(time)
Hàm TIME_TO_SEC() trong SQL trả về số giây được chuyển đổi từ đối số time.
Ví dụ:
SELECT TIME_TO_SEC('22:23:00');Kết quả:
+---------------------------------------------------------+ | TIME_TO_SEC('22:23:00') | +---------------------------------------------------------+ | 80580 | +---------------------------------------------------------+TO_DAYS(date)
Hàm TO_DAYS() trong SQL trả về số ngày (số ngày kể từ năm 0) từ date đã cho.
Ví dụ:
SELECT TO_DAYS(20170707);Kết quả:
+---------------------------------------------------------+ | TO_DAYS(20170707) | +---------------------------------------------------------+ | 736882 | +---------------------------------------------------------+UNIX_TIMESTAMP(), UNIX_TIMESTAMP(date)
Hàm UNIX_TIMESTAMP() trong SQL có 2 dạng. Nếu được gọi với không có đối số, hàm này trả về số giây theo Unix timestamp (kể từ '1970-01-01 00:00:00' UTC) dưới dạng số nguyên không dấu (unsigned integer). Nếu UNIX_TIMESTAMP() được gọi với đối số date, nó trả về giá trị của đối số là giây (kể từ '1970-01-01 00:00:00' UTC). Đối số date có thể là một chuỗi DATE, một chuỗi DATETIME, TIMESTAMP hoặc một số ở định dạng YYMMDD hoặc YYYYMMDD.
Ví dụ 1:
SELECT UNIX_TIMESTAMP();Kết quả:
+---------------------------------------------------------+ | UNIX_TIMESTAMP() | +---------------------------------------------------------+ | 1499232221 | +---------------------------------------------------------+Ví dụ 2:
SELECT UNIX_TIMESTAMP('1970-01-02 00:00:00');Kết quả:
+---------------------------------------------------------+ | UNIX_TIMESTAMP('1970-01-02 00:00:00') | +---------------------------------------------------------+ | 61200 | +---------------------------------------------------------+UTC_DATE, UTC_DATE()
Hàm UTC_DATE() trong SQL trả về ngày giờ UTC hiện tại dưới dạng một giá trị trong định dạng 'YYYY-MM-DD' hoặc YYYYMMDD, tùy thuộc vào việc hàm được sử dụng trong một chuỗi hay ngữ cảnh số.
Ví dụ:
SELECT UTC_DATE(), UTC_DATE() + 0;Kết quả:
+----------------------------------------+ | UTC_DATE() | UTC_DATE() + 0 | +----------------------------------------+ | 2017-07-07 | 20170707 | +----------------------------------------+UTC_TIME, UTC_TIME()
Hàm UTC_TIME() trong SQL trả về thời gian UTC hiện tại dưới dạng giá trị 'HH: MM: SS' hoặc HHMMSS, tùy thuộc vào việc hàm được sử dụng trong một chuỗi hay ngữ cảnh số.
Ví dụ:
SELECT UTC_TIME(), UTC_TIME() + 0;Kết quả:
+--------------------------------------+ | UTC_TIME() | UTC_TIME() + 0 | +--------------------------------------+ | 05:40:20 | 54020 | +--------------------------------------+UTC_TIMESTAMP, UTC_TIMESTAMP()
Hàm UTC_TIMESTAMP() trong SQL trả về ngày tháng hiện tại của UTC là một giá trị trong định dạng 'YYYY-MM-DD HH: MM: SS' hoặc YYYYMMDDHHMMSS, tùy thuộc vào việc hàm được sử dụng trong một chuỗi hay trong một ngữ cảnh số.
Ví dụ:
SELECT UTC_TIMESTAMP(), UTC_TIMESTAMP() + 0;Kết quả:
+--------------------------------------------------+ | UTC_TIMESTAMP() | UTC_TIMESTAMP() + 0 | +--------------------------------------------------+ | 2017-07-05 06:26:51 | 20170705062651 | +--------------------------------------------------+WEEK(date, mode)
Hàm WEEK() trong SQL trả về số tuần cho ngày tháng. Hình thức hai đối số của WEEK() cho phép bạn xác định liệu tuần bắt đầu vào Sunday hay Monday và giá trị trả về có nằm trong khoảng từ 0 đến 53 hay từ 1 đến 53. Nếu không sử dụng mode, giá trị của biến hệ thống default_week_format được sử dụng.
Mode | Ngày đầu tuần | Phạm vi | Tuần 1 là tuần đầu tiên. |
---|---|---|---|
0 | Sunday | 0-53 | Với một Chủ Nhật trong năm nay |
1 | Monday | 0-53 | Với hơn 3 ngày trong năm nay |
2 | Sunday | 1-53 | Với một Chủ Nhật trong năm nay |
3 | Monday | 1-53 | Với hơn 3 ngày trong năm nay |
4 | Sunday | 0-53 | Với hơn 3 ngày trong năm nay |
5 | Monday | 0-53 | Với một thứ Hai trong năm nay |
6 | Sunday | 1-53 | Với hơn 3 ngày trong năm nay |
7 | Monday | 1-53 | Với một thứ Hai trong năm nay |
Ví dụ:
SELECT WEEK('2017-07-09');Kết quả:
+-------------------------------+ | WEEK('2017-07-09') | +-------------------------------+ | 27 | +-------------------------------+WEEKDAY(date)
Hàm WEEKDAY() trong SQL trả về chỉ số ngày trong tuần (0 = Thứ Hai, 1 = Thứ Ba, 6 = Chủ Nhật).
Ví dụ:
SELECT WEEKDAY('2017-07-09 22:23:00');Kết quả:
+----------------------------------------+ | WEEKDAY('2017-07-09 22:23:00') | +----------------------------------------+ | 6 | +----------------------------------------+WEEKOFYEAR(date)
Hàm WEEKOFYEAR() trong SQL trả về chỉ số tuần của date đã cho là một con số trong khoảng từ 1 đến 53. WEEKOFYEAR() là một chức năng tương đương với WEEK(date, mode) với mode = 3.
Ví dụ:
SELECT WEEKOFYEAR('2017-07-09');Kết quả:
+----------------------------------------+ | WEEKOFYEAR('2017-07-09') | +----------------------------------------+ | 27 | +----------------------------------------+YEAR(date)
Hàm YEAR() trong SQL trả về năm từ date đã cho, nó trả về NULL khi date không hợp lệ.
Ví dụ:
SELECT YEAR('2017-07-05');Kết quả:
+----------------------------------------+ | YEAR('2017-07-05') | +----------------------------------------+ | 2017 | +----------------------------------------+YEARWEEK(date), YEARWEEK(date, mode)
Hàm YEARWEEK() trong SQL trả về năm và và từ date đã cho. Đối số mode hoạt động như đối số mode trong hàm WEEK(). Năm trong kết quả trả về có thể khác với năm trong đối số date đối với ngày đầu tiên và tuần cuối cùng của năm.
Ví dụ 1: Năm trong kết quả trả về giống với năm trong đối số date
SELECT YEARWEEK('2017-01-01');Kết quả:
+------------------------------------------+ | SELECT YEARWEEK('2017-01-01') | +------------------------------------------+ | 201701 | +------------------------------------------+Ví dụ 2: Năm trong kết quả trả về khác với năm trong đối số date
SELECT YEARWEEK('2016-01-01');Kết quả:
+------------------------------------------+ | SELECT YEARWEEK('2016-01-01') | +------------------------------------------+ | 201552 | +------------------------------------------+ Lưu ý: Số tuần trả về từ YEARWEEK() khác với giá trị mà WEEK() trả về (0) đối với đối số tùy chọn 0 hoặc 1. Hàm WEEK() trả về tuần trong ngữ cảnh của năm của date đã cho.Ví dụ 3:
SELECT YEARWEEK('2016-01-01'), WEEK('2016-01-01', 0);Kết quả:
+---------------------------------------------------+ | YEARWEEK('2016-01-01') | WEEK('2016-01-01', 0) | +---------------------------------------------------+ | 201552 | 0 | +---------------------------------------------------+ Bài tiếp theo: Bảng tạm trong SQL Ký tự đại diện trong SQL Bảng tạm trong SQLRecent Updates
Xử lý duplicate trong SQLWeb SQL Database trong HTML5Lệnh DELETE MySQL trong PythonLệnh UPDATE MySQL trong PythonLệnh SELECT MySQL trong PythonLệnh INSERT MySQL trong PythonTạo bảng MySQL trong PythonTạo new database MySQL trong PythonKết nối Python với MySQLCài đặt môi trường MySQL cho PythonVí dụ Hibernate 3 XML Mapping - SQLServer 2017Ví dụ Hibernate 4 Annotation Mapping - MySQLSắp Tết 2024 Rồi! - Còn bao nhiêu ngày nữa là đến tết 2024?VietTuts on facebook
Học Lập Trình Online Miễn Phí - VietTuts.Vn
Danh Sách Bài Học
Học Java | Hibernate | Spring Học Excel | Excel VBA Học Servlet | JSP | Struts2 Học C | C++ | C# Học Python Học SQL
Bài Tập Có Lời Giải
Bài tập Java Bài tập C Bài tập C++ Bài tập C# Bài tập Python Ví dụ Excel VBA
Câu Hỏi Phỏng Vấn
201 câu hỏi phỏng vấn java 25 câu hỏi phỏng vấn servlet 75 câu hỏi phỏng vấn jsp 52 câu hỏi phỏng vấn Hibernate 70 câu hỏi phỏng vấn Spring 57 câu hỏi phỏng vấn SQL
Từ khóa » Hàm Lấy Ngày Tháng Năm Hiện Tại Trong Sql
-
Tính Toán Và Xử Lý Ngày Tháng Bằng Câu Lệnh SQL Như Thế Nào?
-
Hàm GETDATE Trong SQL Server
-
Lấy Ngày Hiện Tại Trong Sql
-
SQL Server: Hàm Ngày Tháng Và Thời Gian | V1Study
-
Tính Toán Và Xử Lí Ngày Tháng Bằng Câu Lệnh SQL - Viblo
-
Lấy Ngày Hiện Tại Trong Sql
-
Lấy Ngày Hiện Tại Trong Sql
-
GETDATE - Hàm Thời Gian - SQL & Database
-
Cách Lấy Ngày Hiện Tại Trong MySQL - Freetuts
-
Cách Nhập Ngày Tháng Năm Trong SQL - Xây Nhà
-
Cách Dùng Hàm Lấy Ra Ngày Tháng Năm Hiện Tại ? Lab 3.B4
-
Hàm Xử Lý Date Trong SQL - Hoclaptrinh
-
Lab 3.B4: Sử Dụng Hàm Xử Lý Ngày Tháng Năm (Datename, Datediff ...
-
Ví Dụ Về Dùng Ngày Tháng Làm Tiêu Chí Trong Truy Vấn Access