SQL - funkcje daty

Poniższa tabela zawiera listę wszystkich ważnych funkcji związanych z datą i godziną dostępnych za pośrednictwem języka SQL. RDBMS obsługuje różne inne funkcje. Podana lista jest oparta na bazie danych MySQL RDBMS.

Sr.No.	Opis funkcji
1	ADDDATE () Dodaje daty
2	DODAJ CZAS() Dodaje czas
3	CONVERT_TZ () Konwertuje z jednej strefy czasowej do drugiej
4	CURDATE () Zwraca bieżącą datę
5	CURRENT_DATE (), CURRENT_DATE Synonimy dla CURDATE ()
6	CURRENT_TIME (), CURRENT_TIME Synonimy dla CURTIME ()
7	CURRENT_TIMESTAMP (), CURRENT_TIMESTAMP Synonimy dla NOW ()
8	CURTIME () Zwraca aktualny czas
9	DATE_ADD () Dodaje dwie daty
10	FORMAT DATY() Formatuje datę jak określono
11	DATE_SUB () Odejmuje dwie daty
12	DATA() Wyodrębnia część daty z wyrażenia daty lub daty i godziny
13	DATEDIFF () Odejmuje dwie daty
14	DZIEŃ() Synonim dla DAYOFMONTH ()
15	DAYNAME () Zwraca nazwę dnia tygodnia
16	DZIEŃ MIESIĄCA() Zwraca dzień miesiąca (1-31)
17	DZIEŃ TYGODNIA() Zwraca indeks argumentu dnia tygodnia
18	DAYOFYEAR () Zwraca dzień roku (1-366)
19	WYCIĄG Wydobywa część daty
20	FROM_DAYS () Konwertuje numer dnia na datę
21	FROM_UNIXTIME () Formatuje datę jako znacznik czasu systemu UNIX
22	GODZINA() Wydobywa godzinę
23	OSTATNI DZIEŃ Zwraca ostatni dzień miesiąca dla argumentu
24	LOCALTIME (), LOCALTIME Synonim TERAZ ()
25	LOCALTIMESTAMP, LOCALTIMESTAMP () Synonim TERAZ ()
26	MAKEDATE () Tworzy datę na podstawie roku i dnia roku
27	MAKETIME MAKETIME ()
28	MIKROSEKUNDA() Zwraca mikrosekundy z argumentu
29	MINUTA() Zwraca minutę z argumentu
30	MIESIĄC() Zwróć miesiąc od minionej daty
31	NAZWA MIESIĄCA () Zwraca nazwę miesiąca
32	TERAZ() Zwraca bieżącą datę i godzinę
33	PERIOD_ADD () Dodaje okres do roku-miesiąca
34	PERIOD_DIFF () Zwraca liczbę miesięcy między okresami
35	JEDNA CZWARTA() Zwraca kwartał z argumentu daty
36	SEC_TO_TIME () Konwertuje sekundy na format „HH: MM: SS”
37	DRUGA() Zwraca sekundę (0–59)
38	STR_TO_DATE () Konwertuje ciąg na datę
39	SUBDATE () Wywołane z trzema argumentami jest synonimem DATE_SUB ()
40	SUBTIME () Odejmuje czasy
41	SYSDATE () Zwraca czas, w którym funkcja jest wykonywana
42	FORMAT CZASU() Formaty jako czas
43	TIME_TO_SEC () Zwraca argument przekonwertowany na sekundy
44	CZAS() Wyodrębnia część czasu z przekazanego wyrażenia
45	TIMEDIFF () Odejmuje czas
46	ZNAK CZASU() Za pomocą jednego argumentu funkcja zwraca datę lub wyrażenie typu data i godzina. W przypadku dwóch argumentów, suma argumentów
47	TIMESTAMPADD () Dodaje interwał do wyrażenia datetime
48	TIMESTAMPDIFF () Odejmuje przedział czasu od wyrażenia typu data i godzina
49	TO_DAYS () Zwraca argument daty przekonwertowany na dni
50	UNIX_TIMESTAMP () Zwraca znacznik czasu UNIX
51	UTC_DATE () Zwraca bieżącą datę UTC
52	UTC_TIME () Zwraca bieżący czas UTC
53	UTC_TIMESTAMP () Zwraca bieżącą datę i godzinę UTC
54	TYDZIEŃ() Zwraca numer tygodnia
55	DZIEŃ POWSZEDNI() Zwraca indeks dnia tygodnia
56	WEEKOFYEAR () Zwraca tydzień kalendarzowy z daty (1-53)
57	ROK() Zwraca rok
58	YEARWEEK () Zwraca rok i tydzień

ADDDATE (data, INTERVAL jednostka wyrażenia), ADDDATE (wyrażenie, dni)

Po wywołaniu z postacią INTERVAL drugiego argumentu, ADDDATE () jest synonimem DATE_ADD (). Powiązana funkcja SUBDATE () jest synonimem DATE_SUB (). Aby uzyskać informacje na temat argumentu jednostki INTERVAL, zobacz dyskusję na temat DATE_ADD ().

mysql> SELECT DATE_ADD('1998-01-02', INTERVAL 31 DAY);
+---------------------------------------------------------+
| DATE_ADD('1998-01-02', INTERVAL 31 DAY)                 |
+---------------------------------------------------------+
| 1998-02-02                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT ADDDATE('1998-01-02', INTERVAL 31 DAY);
+---------------------------------------------------------+
| ADDDATE('1998-01-02', INTERVAL 31 DAY)                  |
+---------------------------------------------------------+
| 1998-02-02                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Wywołany z postacią dni drugiego argumentu MySQL traktuje go jako całkowitą liczbę dni, które mają być dodane do wyrażenia.

mysql> SELECT ADDDATE('1998-01-02', 31);
+---------------------------------------------------------+
| DATE_ADD('1998-01-02', INTERVAL 31 DAY)                 |
+---------------------------------------------------------+
| 1998-02-02                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

ADDTIME (wyr1; wyr2)

ADDTIME () dodaje wyrażenie 2 do wyrażenia 1 i zwraca wynik. Wyr1 jest wyrażeniem czasu lub daty i godziny, natomiast wyrażenie2 jest wyrażeniem czasu.

mysql> SELECT ADDTIME('1997-12-31 23:59:59.999999','1 1:1:1.000002');
+---------------------------------------------------------+
| DATE_ADD('1997-12-31 23:59:59.999999','1 1:1:1.000002') |
+---------------------------------------------------------+
| 1998-01-02 01:01:01.000001                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

CONVERT_TZ (dt, from_tz, to_tz)

To konwertuje wartość daty i godziny dt ze strefy czasowej podanej przez from_tz na strefę czasową podaną przez to_tz i zwraca wynikową wartość. Ta funkcja zwraca NULL, jeśli argumenty są nieprawidłowe.

mysql> SELECT CONVERT_TZ('2004-01-01 12:00:00','GMT','MET');
+---------------------------------------------------------+
| CONVERT_TZ('2004-01-01 12:00:00','GMT','MET')           |
+---------------------------------------------------------+
| 2004-01-01 13:00:00                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT CONVERT_TZ('2004-01-01 12:00:00','+00:00','+10:00');
+---------------------------------------------------------+
| CONVERT_TZ('2004-01-01 12:00:00','+00:00','+10:00')     |
+---------------------------------------------------------+
| 2004-01-01 22:00:00                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

CURDATE ()

Zwraca bieżącą datę jako wartość w formacie „RRRR-MM-DD” lub RRRRMMDD, w zależności od tego, czy funkcja jest używana w ciągu, czy w kontekście liczbowym.

mysql> SELECT CURDATE();
+---------------------------------------------------------+
| CURDATE()                                               |
+---------------------------------------------------------+
| 1997-12-15                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT CURDATE() + 0;
+---------------------------------------------------------+
| CURDATE() + 0                                           |
+---------------------------------------------------------+
| 19971215                                                |
+---------------------------------------------------------+
1 row in set (0.00 sec)

CURRENT_DATE i CURRENT_DATE ()

CURRENT_DATE i CURRENT_DATE () są synonimami CURDATE ()

CURTIME ()

Zwraca bieżący czas jako wartość w formacie „HH: MM: SS” lub HHMMSS, w zależności od tego, czy funkcja jest używana w ciągu, czy w kontekście liczbowym. Wartość jest wyrażona w aktualnej strefie czasowej.

mysql> SELECT CURTIME();
+---------------------------------------------------------+
| CURTIME()                                               |
+---------------------------------------------------------+
| 23:50:26                                                |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT CURTIME() + 0;
+---------------------------------------------------------+
| CURTIME() + 0                                           |
+---------------------------------------------------------+
| 235026                                                  |
+---------------------------------------------------------+
1 row in set (0.00 sec)

CURRENT_TIME i CURRENT_TIME ()

CURRENT_TIME i CURRENT_TIME () są synonimami CURTIME ().

CURRENT_TIMESTAMP i CURRENT_TIMESTAMP ()

CURRENT_TIMESTAMP i CURRENT_TIMESTAMP () to synonimy NOW ().

DATE (wyr)

Wyodrębnia część daty z wyrażenia daty lub daty i godziny.

mysql> SELECT DATE('2003-12-31 01:02:03');
+---------------------------------------------------------+
| DATE('2003-12-31 01:02:03')                             |
+---------------------------------------------------------+
|  2003-12-31                                             |
+---------------------------------------------------------+
1 row in set (0.00 sec)

DATEDIFF (wyr1; wyr2)

DATEDIFF () zwraca wyr1. wyrażenie2 wyrażone jako wartość w dniach od jednej daty do drugiej. Wyrażenie 1 i 2 są wyrażeniami daty lub daty i godziny. W obliczeniach używane są tylko części wartości dotyczące daty.

mysql> SELECT DATEDIFF('1997-12-31 23:59:59','1997-12-30');
+---------------------------------------------------------+
| DATEDIFF('1997-12-31 23:59:59','1997-12-30')            |
+---------------------------------------------------------+
| 1                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

DATE_ADD (data, jednostka wyrażenia INTERVAL), DATE_SUB (data, jednostka wyrażenia INTERVAL)

Te funkcje wykonują arytmetykę dat. Plikdateto wartość DATETIME lub DATE określająca datę początkową. Plikexprjest wyrażeniem określającym wartość interwału, która ma zostać dodana lub odjęta od daty początkowej. Wyrażenie jest łańcuchem; może zaczynać się od „-” dla przedziałów ujemnych.

ZA unit to słowo kluczowe wskazujące jednostki, w których powinno być interpretowane wyrażenie.

Plik INTERVAL słowo kluczowe i specyfikator jednostki nie uwzględniają wielkości liter.

W poniższej tabeli przedstawiono oczekiwaną postać argumentu wyrażenia dla każdej wartości jednostki.

wartość jednostki	Oczekiwano exprFormat
MIKROSEKUNDA	MIKROSEKUNDY
DRUGA	SEKUNDY
MINUTA	MINUTY
GODZINA	GODZINY
DZIEŃ	DNI
TYDZIEŃ	TYGODNIE
MIESIĄC	MIESIĘCY
JEDNA CZWARTA	MIESZKANIE
ROK	LAT
SECOND_MICROSECOND	„SECONDS.MICROSECONDS”
MINUTE_MICROSECOND	„MINUTY.MIKROSEKUNDY”
MINUTE_SECOND	„MINUTES: SECONDS”
HOUR_MICROSECOND	„HOURS.MICROSECONDS”
HOUR_SECOND	„HOURS: MINUTES: SECONDS”
HOUR_MINUTE	„HOURS: MINUTES”
DAY_MICROSECOND	„DNI.MIKROSEKUND”
DAY_SECOND	„DNI GODZ .: MINUTY: SEKUNDY”
DAY_MINUTE	„DNI GODZ .: MINUTY”
DAY_HOUR	„DNI GODZ.”
YEAR_MONTH	„LATA-MIESIĄCE”

Wartości QUARTER i WEEKsą dostępne w MySQL 5.0.0. wersja.

mysql> SELECT DATE_ADD('1997-12-31 23:59:59', 
   -> INTERVAL '1:1' MINUTE_SECOND);
+---------------------------------------------------------+
| DATE_ADD('1997-12-31 23:59:59', INTERVAL...             |
+---------------------------------------------------------+
| 1998-01-01 00:01:00                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT DATE_ADD('1999-01-01', INTERVAL 1 HOUR);
+---------------------------------------------------------+
| DATE_ADD('1999-01-01', INTERVAL 1 HOUR)                 |
+---------------------------------------------------------+
| 1999-01-01 01:00:00                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

DATE_FORMAT (data, format)

To polecenie formatuje wartość daty zgodnie z ciągiem formatu.

W ciągu formatu mogą być używane następujące specyfikatory. Znak „%” jest wymagany przed znakami specyfikatora formatu.

Sr.No.	Specyfikator i opis
1	%a Skrócona nazwa dnia tygodnia (niedz. Sobota)
2	%b Skrócona nazwa miesiąca (styczeń – grudzień)
3	%c Miesiąc, numerycznie (0..12)
4	%D Dzień miesiąca z angielskim sufiksem (0, 1, 2, 3,.)
5	%d Dzień miesiąca, numeryczny (00–31)
6	%e Dzień miesiąca, numerycznie (0..31)
7	%f Mikrosekundy (000000..999999)
8	%H Godzina (00–23)
9	%h Godzina (01..12)
10	%I Godzina (01..12)
11	%i Minuty, numeryczne (00–59)
12	%j Dzień roku (001..366)
13	%k Godzina (0–23)
14	%l Godzina (1–12)
15	%M Nazwa miesiąca (styczeń – grudzień)
16	%m Miesiąc, numerycznie (00..12)
17	%p Rano lub wieczorem
18	%r Czas, 12-godzinny (gg: mm: ss, a następnie AM lub PM)
19	%S Sekundy (00–59)
20	%s Sekundy (00–59)
21	%T Czas, 24-godzinny (gg: mm: ss)
22	%U Tydzień (00..53), gdzie niedziela jest pierwszym dniem tygodnia
23	%u Tydzień (00..53), gdzie poniedziałek jest pierwszym dniem tygodnia
24	%V Tydzień (01..53), gdzie niedziela jest pierwszym dniem tygodnia; używane z% X
25	%v Tydzień (01..53), gdzie poniedziałek jest pierwszym dniem tygodnia; używane z% x
26	%W Nazwa dnia tygodnia (niedziela… sobota)
27	%w Dzień tygodnia (0 = niedziela..6 = sobota)
28	%X Rok dla tygodnia, w którym niedziela jest pierwszym dniem tygodnia, numerycznie, cztery cyfry; używany z% V
29	%x Rok tygodnia, w którym poniedziałek jest pierwszym dniem tygodnia, numerycznie, cztery cyfry; używane z% v
30	%Y Rok, numeryczny, cztery cyfry
31	%y Rok, numeryczny (dwie cyfry)
32	%% Dosłowny.%. postać
33	%x x, dla any.x. nie wymienione powyżej

mysql> SELECT DATE_FORMAT('1997-10-04 22:23:00', '%W %M %Y');
+---------------------------------------------------------+
| DATE_FORMAT('1997-10-04 22:23:00', '%W %M %Y')          |
+---------------------------------------------------------+
| Saturday October 1997                                   |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT DATE_FORMAT('1997-10-04 22:23:00'
   -> '%H %k %I %r %T %S %w');
+---------------------------------------------------------+
| DATE_FORMAT('1997-10-04 22:23:00.......                 |
+---------------------------------------------------------+
|  22 22 10 10:23:00 PM 22:23:00 00 6                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

DATE_SUB (data, jednostka wyrażenia INTERVAL)

Jest to podobne do funkcji DATE_ADD ().

Data dnia)

DAY () jest synonimem funkcji DAYOFMONTH ().

DAYNAME (data)

Zwraca nazwę dnia tygodnia dla daty.

mysql> SELECT DAYNAME('1998-02-05');
+---------------------------------------------------------+
| DAYNAME('1998-02-05')                                   |
+---------------------------------------------------------+
| Thursday                                                |
+---------------------------------------------------------+
1 row in set (0.00 sec)

DAYOFMONTH (data)

Zwraca dzień miesiąca jako datę z zakresu od 0 do 31.

mysql> SELECT DAYOFMONTH('1998-02-03');
+---------------------------------------------------------+
| DAYOFMONTH('1998-02-03')                                |
+---------------------------------------------------------+
| 3                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

DAYOFWEEK (data)

Zwraca indeks dni tygodnia dla daty (1 = niedziela, 2 = poniedziałek,., 7 = sobota). Te wartości indeksu odpowiadają standardowi ODBC.

mysql> SELECT DAYOFWEEK('1998-02-03');
+---------------------------------------------------------+
|DAYOFWEEK('1998-02-03')                                  |
+---------------------------------------------------------+
| 3                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

DAYOFYEAR (data)

Zwraca dzień roku dla daty z zakresu od 1 do 366.

mysql> SELECT DAYOFYEAR('1998-02-03');
+---------------------------------------------------------+
| DAYOFYEAR('1998-02-03')                                 |
+---------------------------------------------------------+
| 34                                                      |
+---------------------------------------------------------+
1 row in set (0.00 sec)

EKSTRAKT (jednostka OD daty)

Funkcja EXTRACT () używa tego samego rodzaju specyfikatorów jednostek, co DATE_ADD () lub DATE_SUB (), ale wyodrębnia części z daty zamiast wykonywania arytmetyki na podstawie daty.

mysql> SELECT EXTRACT(YEAR FROM '1999-07-02');
+---------------------------------------------------------+
| EXTRACT(YEAR FROM '1999-07-02')                         |
+---------------------------------------------------------+
| 1999                                                    |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT EXTRACT(YEAR_MONTH FROM '1999-07-02 01:02:03');
+---------------------------------------------------------+
| EXTRACT(YEAR_MONTH FROM '1999-07-02 01:02:03')          |
+---------------------------------------------------------+
| 199907                                                  |
+---------------------------------------------------------+
1 row in set (0.00 sec)

FROM_DAYS (N)

Biorąc pod uwagę numer dnia N, zwraca wartość DATA.

mysql> SELECT FROM_DAYS(729669);
+---------------------------------------------------------+
| FROM_DAYS(729669)                                       |
+---------------------------------------------------------+
| 1997-10-07                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Note- Używaj ostrożnie FROM_DAYS () w przypadku starych dat. Nie jest przeznaczony do stosowania z wartościami poprzedzającymi nadejście kalendarza gregoriańskiego (1582).

FROM_UNIXTIME (unix_timestamp)

FROM_UNIXTIME (unix_timestamp, format)

Zwraca reprezentację unix_timestampargument jako wartość w formacie „RRRR-MM-DD GG: MM: SS lub RRRRMMDDGGMMSS, w zależności od tego, czy funkcja jest używana w ciągu, czy w kontekście liczbowym. Wartość jest wyrażona w aktualnej strefie czasowej. Argument unix_timestamp to wewnętrzne wartości znacznika czasu, które są tworzone przezUNIX_TIMESTAMP() funkcjonować.

Jeśli podano format, wynik jest formatowany zgodnie z ciągiem formatującym, który jest używany w taki sam sposób, jak podano we wpisie dla DATE_FORMAT() funkcjonować.

mysql> SELECT FROM_UNIXTIME(875996580);
+---------------------------------------------------------+
| FROM_UNIXTIME(875996580)                                |
+---------------------------------------------------------+
| 1997-10-04 22:23:00                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

HOUR (czas)

Zwraca godzinę dla czasu. Zakres zwracanej wartości wynosi od 0 do 23 dla wartości dotyczących pory dnia. Jednak zakres wartości CZAS jest w rzeczywistości znacznie większy, więc GODZINA może zwracać wartości większe niż 23.

mysql> SELECT HOUR('10:05:03');
+---------------------------------------------------------+
| HOUR('10:05:03')                                        |
+---------------------------------------------------------+
| 10                                                      |
+---------------------------------------------------------+
1 row in set (0.00 sec)

LAST_DAY (data)

Pobiera wartość typu data lub data-godzina i zwraca odpowiednią wartość z ostatniego dnia miesiąca. Zwraca NULL, jeśli argument jest nieprawidłowy.

mysql> SELECT LAST_DAY('2003-02-05');
+---------------------------------------------------------+
| LAST_DAY('2003-02-05')                                  |
+---------------------------------------------------------+
| 2003-02-28                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

LOCALTIME i LOCALTIME ()

LOCALTIME i LOCALTIME () to synonimy NOW ().

LOCALTIMESTAMP i LOCALTIMESTAMP ()

LOCALTIMESTAMP i LOCALTIMESTAMP () to synonimy NOW ().

MAKEDATE (rok, dzień roku)

Zwraca datę, podaną wartość roku i dnia roku. Wartość dayofyear musi być większa niż 0 lub wynik będzie miał wartość NULL.

mysql> SELECT MAKEDATE(2001,31), MAKEDATE(2001,32);
+---------------------------------------------------------+
| MAKEDATE(2001,31), MAKEDATE(2001,32)                    |
+---------------------------------------------------------+
| '2001-01-31', '2001-02-01'                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

MAKETIME (godzina, minuta, sekunda)

Zwraca wartość czasu obliczoną na podstawie godziny, minuty i sekundy.

mysql> SELECT MAKETIME(12,15,30);
+---------------------------------------------------------+
| MAKETIME(12,15,30)                                      |
+---------------------------------------------------------+
| '12:15:30'                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

MICROSECOND (wyrażenie)

Zwraca liczbę mikrosekund z wyrażenia czasu lub daty i godziny (wyrażenie) jako liczbę z zakresu od 0 do 999999.

mysql> SELECT MICROSECOND('12:00:00.123456');
+---------------------------------------------------------+
| MICROSECOND('12:00:00.123456')                          |
+---------------------------------------------------------+
| 123456                                                  |
+---------------------------------------------------------+
1 row in set (0.00 sec)

MINUTE (czas)

Zwraca minutę dla czasu z zakresu od 0 do 59.

mysql> SELECT MINUTE('98-02-03 10:05:03');
+---------------------------------------------------------+
| MINUTE('98-02-03 10:05:03')                             |
+---------------------------------------------------------+
| 5                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

MIESIĄC (data)

Zwraca miesiąc dla daty z zakresu od 0 do 12.

mysql> SELECT MONTH('1998-02-03')
+---------------------------------------------------------+
| MONTH('1998-02-03')                                     |
+---------------------------------------------------------+
| 2                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

MONTHNAME (data)

Zwraca pełną nazwę miesiąca dla daty.

mysql> SELECT MONTHNAME('1998-02-05');
+---------------------------------------------------------+
| MONTHNAME('1998-02-05')                                 |
+---------------------------------------------------------+
| February                                                |
+---------------------------------------------------------+
1 row in set (0.00 sec)

TERAZ()

Zwraca bieżącą datę i godzinę jako wartość w formacie „RRRR-MM-DD GG: MM: SS” lub RRRRMMDDGGMMSS, w zależności od tego, czy funkcja jest używana w kontekście ciągowym, czy liczbowym. Ta wartość jest wyrażona w bieżącej strefie czasowej.

mysql> SELECT NOW();
+---------------------------------------------------------+
| NOW()                                                   |
+---------------------------------------------------------+
| 1997-12-15 23:50:26                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

PERIOD_ADD (P, N)

Dodaje N miesięcy do okresu P (w formacie RRMM lub RRRRMM). Zwraca wartość w formacie RRRRMM. Zauważ, że argument P okresu nie jest wartością daty.

mysql> SELECT PERIOD_ADD(9801,2);
+---------------------------------------------------------+
| PERIOD_ADD(9801,2)                                      |
+---------------------------------------------------------+
| 199803                                                  |
+---------------------------------------------------------+
1 row in set (0.00 sec)

PERIOD_DIFF (P1; P2)

Zwraca liczbę miesięcy między okresami P1 i P2. Okresy P1 i P2 powinny mieć format RRMM lub RRRRMM. Zwróć uwagę, że argumenty okresu P1 i P2 nie są wartościami dat.

mysql> SELECT PERIOD_DIFF(9802,199703);
+---------------------------------------------------------+
| PERIOD_DIFF(9802,199703)                                |
+---------------------------------------------------------+
| 11                                                      |
+---------------------------------------------------------+
1 row in set (0.00 sec)

KWARTAŁ (data)

Zwraca kwartał roku dla daty z zakresu od 1 do 4.

mysql> SELECT QUARTER('98-04-01');
+---------------------------------------------------------+
| QUARTER('98-04-01')                                     |
+---------------------------------------------------------+
| 2                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Drugi raz)

Zwraca sekundę dla czasu z zakresu od 0 do 59.

mysql> SELECT SECOND('10:05:03');
+---------------------------------------------------------+
| SECOND('10:05:03')                                      |
+---------------------------------------------------------+
| 3                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

SEC_TO_TIME (sekundy)

Zwraca argument sekund, konwertowany na godziny, minuty i sekundy, jako wartość w formacie „HH: MM: SS” lub HHMMSS, w zależności od tego, czy funkcja jest używana w kontekście ciągowym, czy liczbowym.

mysql> SELECT SEC_TO_TIME(2378);
+---------------------------------------------------------+
| SEC_TO_TIME(2378)                                       |
+---------------------------------------------------------+
| 00:39:38                                                |
+---------------------------------------------------------+
1 row in set (0.00 sec)

STR_TO_DATE (str, format)

To jest odwrotność funkcji DATE_FORMAT (). Pobiera ciąg znaków i format ciągu formatu. Funkcja STR_TO_DATE () zwraca wartość DATETIME, jeśli łańcuch formatu zawiera zarówno części daty, jak i godziny. W przeciwnym razie zwraca wartość DATA lub CZAS, jeśli ciąg zawiera tylko części daty lub godziny.

mysql> SELECT STR_TO_DATE('04/31/2004', '%m/%d/%Y');
+---------------------------------------------------------+
| STR_TO_DATE('04/31/2004', '%m/%d/%Y')                   |
+---------------------------------------------------------+
| 2004-04-31                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

SUBDATE (data, INTERVAL jednostka wyrażenia) i SUBDATE (wyrażenie, dni)

Po wywołaniu w postaci INTERVAL drugiego argumentu SUBDATE () jest synonimem DATE_SUB (). Aby uzyskać informacje na temat argumentu jednostki INTERVAL, zobacz dyskusję na temat DATE_ADD ().

mysql> SELECT DATE_SUB('1998-01-02', INTERVAL 31 DAY);
+---------------------------------------------------------+
| DATE_SUB('1998-01-02', INTERVAL 31 DAY)                 |
+---------------------------------------------------------+
| 1997-12-02                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT SUBDATE('1998-01-02', INTERVAL 31 DAY);
+---------------------------------------------------------+
| SUBDATE('1998-01-02', INTERVAL 31 DAY)                  |
+---------------------------------------------------------+
| 1997-12-02                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

SUBTIME (wyr1; wyr2)

Funkcja SUBTIME () zwraca wyrażenie1. wyrażenie2 wyrażone jako wartość w tym samym formacie co wyrażenie1. Wartość wyraż1 jest wyrażeniem czasu lub daty i godziny, natomiast wartość wyraż2 jest wyrażeniem czasu.

mysql> SELECT SUBTIME('1997-12-31 23:59:59.999999',
   -> '1 1:1:1.000002');
+---------------------------------------------------------+
| SUBTIME('1997-12-31 23:59:59.999999'...                 |
+---------------------------------------------------------+
| 1997-12-30 22:58:58.999997                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

SYSDATE ()

Zwraca bieżącą datę i godzinę jako wartość w formacie „RRRR-MM-DD GG: MM: SS” lub RRRRMMDDGGMMSS, w zależności od tego, czy funkcja jest używana w ciągu, czy w kontekście liczbowym.

mysql> SELECT SYSDATE();
+---------------------------------------------------------+
| SYSDATE()                                               |
+---------------------------------------------------------+
| 2006-04-12 13:47:44                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

CZAS (wyrażenie)

Wyodrębnia część czasu z wyrażenia czasu lub daty i godziny expr i zwraca go jako ciąg.

mysql> SELECT TIME('2003-12-31 01:02:03');
+---------------------------------------------------------+
| TIME('2003-12-31 01:02:03')                             |
+---------------------------------------------------------+
| 01:02:03                                                |
+---------------------------------------------------------+
1 row in set (0.00 sec)

TIMEDIFF (wyr1; wyr2)

Funkcja TIMEDIFF () zwraca wyrażenie1. wyrażenie2 wyrażone jako wartość czasu. Te wartości wyr1 i wyr2 są wyrażeniami czasu lub daty i godziny, ale obie muszą być tego samego typu.

mysql> SELECT TIMEDIFF('1997-12-31 23:59:59.000001',
   -> '1997-12-30 01:01:01.000002');
+---------------------------------------------------------+
| TIMEDIFF('1997-12-31 23:59:59.000001'.....              |
+---------------------------------------------------------+
|  46:58:57.999999                                        |
+---------------------------------------------------------+
1 row in set (0.00 sec)

TIMESTAMP (wyrażenie), TIMESTAMP (wyrażenie1, wyrażenie2)

Z jednym argumentem ta funkcja zwraca wyrażenie daty lub daty i godziny jako wartość typu data-godzina. Z dwoma argumentami dodaje wyrażenie czasu wyrażenie2 do wyrażenia daty lub daty i godzinyexpr1 i zwraca wynik jako wartość typu data-godzina.

mysql> SELECT TIMESTAMP('2003-12-31');
+---------------------------------------------------------+
| TIMESTAMP('2003-12-31')                                 |
+---------------------------------------------------------+
| 2003-12-31 00:00:00                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

TIMESTAMPADD (jednostka; interwał; datetime_expr)

Ta funkcja dodaje interwał wyrażenia liczb całkowitych do wyrażenia daty lub daty i godziny datetime_expr. Jednostka dla interwału jest określona przez argument jednostki, który powinien być jedną z następujących wartości -

• FRAC_SECOND
• SECOND, MINUTE
• GODZINA, DZIEŃ
• WEEK
• MONTH
• KWARTAŁ lub
• YEAR

Wartość jednostki można określić za pomocą jednego ze słów kluczowych, jak pokazano, lub z przedrostkiem SQL_TSI_.

Na przykład DAY i SQL_TSI_DAY oba są dozwolone.

mysql> SELECT TIMESTAMPADD(MINUTE,1,'2003-01-02');
+---------------------------------------------------------+
| TIMESTAMPADD(MINUTE,1,'2003-01-02')                     |
+---------------------------------------------------------+
| 2003-01-02 00:01:00                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

TIMESTAMPDIFF (jednostka; datetime_expr1; datetime_expr2)

Zwraca całkowitą różnicę między wyrażeniami daty lub daty i godziny datetime_expr1 i datetime_expr2. Jednostka wyniku jest określona przez argument jednostki. Dopuszczalne wartości jednostki są takie same, jak podane w opisie funkcji TIMESTAMPADD ().

mysql> SELECT TIMESTAMPDIFF(MONTH,'2003-02-01','2003-05-01');
+---------------------------------------------------------+
| TIMESTAMPDIFF(MONTH,'2003-02-01','2003-05-01')          |
+---------------------------------------------------------+
| 3                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

TIME_FORMAT (czas, format)

Ta funkcja jest używana podobnie jak funkcja DATE_FORMAT (), ale ciąg formatu może zawierać specyfikatory formatu tylko dla godzin, minut i sekund.

Jeśli wartość czasu zawiera część godzinową większą niż 23,%H i %k specyfikatory formatu godziny generują wartość większą niż zwykły zakres od 0 do 23. Inne specyfikatory formatu godziny tworzą wartość godziny modulo 12.

mysql> SELECT TIME_FORMAT('100:00:00', '%H %k %h %I %l');
+---------------------------------------------------------+
| TIME_FORMAT('100:00:00', '%H %k %h %I %l')              |
+---------------------------------------------------------+
| 100 100 04 04 4                                         |
+---------------------------------------------------------+
1 row in set (0.00 sec)

TIME_TO_SEC (czas)

Zwraca argument czasu przekonwertowany na sekundy.

mysql> SELECT TIME_TO_SEC('22:23:00');
+---------------------------------------------------------+
| TIME_TO_SEC('22:23:00')                                 |
+---------------------------------------------------------+
| 80580                                                   |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Dzisiejsza data)

Podana data zwraca numer dnia (liczbę dni od roku 0).

mysql> SELECT TO_DAYS(950501);
+---------------------------------------------------------+
| TO_DAYS(950501)                                         |
+---------------------------------------------------------+
| 728779                                                  |
+---------------------------------------------------------+
1 row in set (0.00 sec)

UNIX_TIMESTAMP (), UNIX_TIMESTAMP (data)

Jeśli zostanie wywołana bez argumentu, ta funkcja zwraca uniksowy znacznik czasu (sekundy od czasu UTC „1970-01-01 00:00:00”) jako liczbę całkowitą bez znaku. Jeśli funkcja UNIX_TIMESTAMP () zostanie wywołana z argumentem daty, zwraca wartość argumentu w sekundach od czasu UTC „1970-01-01 00:00:00”. data może być ciągiem DATA, DATETIME, TIMESTAMP lub liczbą w formacie RRMMDD lub RRRRMMDD.

mysql> SELECT UNIX_TIMESTAMP();
+---------------------------------------------------------+
| UNIX_TIMESTAMP()                                        |
+---------------------------------------------------------+
| 882226357                                               |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT UNIX_TIMESTAMP('1997-10-04 22:23:00');
+---------------------------------------------------------+
| UNIX_TIMESTAMP('1997-10-04 22:23:00')                   |
+---------------------------------------------------------+
| 875996580                                               |
+---------------------------------------------------------+
1 row in set (0.00 sec)

UTC_DATE, UTC_DATE ()

Zwraca bieżącą datę UTC jako wartość w formacie „RRRR-MM-DD” lub RRRRMMDD, w zależności od tego, czy funkcja jest używana w kontekście ciągowym, czy liczbowym.

mysql> SELECT UTC_DATE(), UTC_DATE() + 0;
+---------------------------------------------------------+
| UTC_DATE(), UTC_DATE() + 0                              |
+---------------------------------------------------------+
| 2003-08-14, 20030814                                    |
+---------------------------------------------------------+
1 row in set (0.00 sec)

UTC_TIME, UTC_TIME ()

Zwraca bieżący czas UTC jako wartość w formacie „HH: MM: SS” lub HHMMSS, w zależności od tego, czy funkcja jest używana w kontekście ciągowym, czy liczbowym.

mysql> SELECT UTC_TIME(), UTC_TIME() + 0;
+---------------------------------------------------------+
| UTC_TIME(), UTC_TIME() + 0                              |
+---------------------------------------------------------+
| 18:07:53, 180753                                        |
+---------------------------------------------------------+
1 row in set (0.00 sec)

UTC_TIMESTAMP, UTC_TIMESTAMP ()

Zwraca bieżącą datę i godzinę UTC jako wartość w formacie „RRRR-MM-DD GG: MM: SS” lub RRRRMMDDGGMMSS, w zależności od tego, czy funkcja jest używana w ciągu, czy w kontekście liczbowym.

mysql> SELECT UTC_TIMESTAMP(), UTC_TIMESTAMP() + 0;
+---------------------------------------------------------+
| UTC_TIMESTAMP(), UTC_TIMESTAMP() + 0                    |
+---------------------------------------------------------+
| 2003-08-14 18:08:04, 20030814180804                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

TYDZIEŃ (data [, tryb])

Ta funkcja zwraca numer tygodnia dla daty. Dwuargumentowa postać TYGODNIA () pozwala określić, czy tydzień zaczyna się w niedzielę, czy w poniedziałek i czy wartość zwracana powinna mieścić się w zakresie od 0 do 53 czy od 1 do 53. Jeśli argument mode zostanie pominięty, używana jest wartość zmiennej systemowej default_week_format

Tryb	Pierwszy dzień tygodnia	Zasięg	Tydzień 1 to pierwszy tydzień.
0	niedziela	0-53	z niedzielą w tym roku
1	poniedziałek	0-53	z więcej niż 3 dniami w tym roku
2	niedziela	1-53	z niedzielą w tym roku
3	poniedziałek	1-53	z więcej niż 3 dniami w tym roku
4	niedziela	0-53	z więcej niż 3 dniami w tym roku
5	poniedziałek	0-53	z poniedziałkiem w tym roku
6	niedziela	1-53	z więcej niż 3 dniami w tym roku
7	poniedziałek	1-53	z poniedziałkiem w tym roku

mysql> SELECT WEEK('1998-02-20');
+---------------------------------------------------------+
| WEEK('1998-02-20')                                      |
+---------------------------------------------------------+
| 7                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

WEEKDAY (data)

Zwraca indeks dni tygodnia dla daty (0 = poniedziałek, 1 = wtorek,. 6 = niedziela).

mysql> SELECT WEEKDAY('1998-02-03 22:23:00');
+---------------------------------------------------------+
| WEEKDAY('1998-02-03 22:23:00')                          |
+---------------------------------------------------------+
| 1                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

WEEKOFYEAR (data)

Zwraca tydzień kalendarzowy z daty jako liczbę z zakresu od 1 do 53. WEEKOFYEAR () to funkcja zgodności, która jest odpowiednikiem WEEK (data, 3).

mysql> SELECT WEEKOFYEAR('1998-02-20');
+---------------------------------------------------------+
| WEEKOFYEAR('1998-02-20')                                |
+---------------------------------------------------------+
| 8                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

ROK (data)

Zwraca rok dla daty z zakresu od 1000 do 9999 lub 0 dla wartości zero. data.

mysql> SELECT YEAR('98-02-03');
+---------------------------------------------------------+
| YEAR('98-02-03')                                        |
+---------------------------------------------------------+
| 1998                                                    |
+---------------------------------------------------------+
1 row in set (0.00 sec)

YEARWEEK (data), YEARWEEK (data, tryb)

Zwraca rok i tydzień dla daty. Argument trybu działa dokładnie tak samo, jak argument trybu funkcji WEEK (). Wynikowy rok może różnić się od roku w argumencie data dla pierwszego i ostatniego tygodnia roku.

mysql> SELECT YEARWEEK('1987-01-01');
+---------------------------------------------------------+
| YEAR('98-02-03')YEARWEEK('1987-01-01')                  |
+---------------------------------------------------------+
| 198653                                                  |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Note - Numer tygodnia różni się od tego, co funkcja WEEK () zwróciłaby (0) dla opcjonalnych argumentów 0 lub 1, ponieważ WEEK () zwraca następnie tydzień w kontekście danego roku.