Funkcje skalarne ODBC dla daty i godziny w SQL Server (przykłady T-SQL)

Podczas uruchamiania instrukcji T-SQL w programie SQL Server można używać funkcji skalarnych ODBC. Istnieją różne typy funkcji skalarnych ODBC, w tym funkcje łańcuchowe, funkcje numeryczne, funkcje systemowe i oczywiście funkcje daty/czasu (określane również jako funkcje daty, czasu i przedziału).

Poniżej znajdują się przykłady funkcji daty, czasu i interwału, których można używać w SQL Server.

Składnia

Po pierwsze, oto składnia, której musisz użyć za każdym razem, gdy wywołujesz funkcję skalarną ODBC:

SELECT {fn  [ (,....n)] }

Gdzie to nazwa funkcji i (,....n) to dowolna liczba opcjonalnych argumentów.

 
 Najważniejszą rzeczą do zapamiętania jest to, że kiedy wywołujesz funkcję skalarną ODBC, musisz umieścić wywołanie funkcji w nawiasach klamrowych ({} ) i poprzedź nazwę przedrostkiem fn .
 Przykład 1 – TERAZ()
 
 Ta funkcja zwraca bieżącą datę i godzinę jako wartość znacznika czasu.
 WYBIERZ {fn NOW()} jako wynik;
 
 Wynik:
 +-------------------------+| Wynik ||-------------------------|| 2018-06-13 21:52:25.667 |+------------------------------+
 Przykład 2 – znacznik czasu, data i godzina
 
 CURRENT_TIMESTAMP() funkcja zwraca bieżącą lokalną datę i czas lokalny jako wartość znacznika czasu. Możesz także użyć CURRENT_DATE() aby zwrócić tylko część daty i/lub CURRENT_TIME() aby zwrócić tylko część czasu.
 SELECT {fn CURRENT_TIMESTAMP()} AS 'Data i godzina', {fn CURRENT_DATE()} AS 'Data', {fn CURRENT_TIME()} AS 'Czas';
 
 Wynik:
 +--------------------------+-------------+----------- -------+| Data i czas | Data | Czas ||--------------------------+-------------+------------ ------|| 2018-06-13 21:57:29.197 | 2018-06-13 | 21:57:29.197 |+--------------------------+---------------+----- ----------+
 
 Ponadto CURRENT_TIMESTAMP() i CURRENT_TIME() obydwa akceptują opcjonalny argument w celu określenia sekundowej dokładności zwracanej wartości.
 
 Przykłady:
 SELECT {fn CURRENT_TIMESTAMP(3)} AS „Data i godzina”, {fn CURRENT_TIME(6)} AS „Czas”;
 
 Wynik:
 +-------------------------+-----------------+| Data i czas | Czas ||-------------------------+-----------------|| 2018-06-13 22:00:59.263 | 22:00:59.263000 |+-----------------------------------------+----------------- +
 
 W tym przykładzie CURRENT_TIMESTAMP() zwraca dokładność 3 sekund, podczas gdy CURRENT_TIME() zwraca precyzję w sekundach wynoszącą 6.
 Przykład 3 – CURDATE() i CURTIME()
 
 Możesz użyć CURDATE() i/lub CURTIME() jako alternatywa dla powyższych funkcji daty i czasu:
 SELECT {fn CURDATE()} AS 'Data', {fn CURTIME()} AS 'Godzina';
 
 Wynik:
 +------------+---------------+| Data | Czas ||-------------+--------------|| 2018-06-13 | 22:05:20.013 |+-------------+-----------------+
 
 Pamiętaj, że te argumenty nie akceptują żadnych argumentów, więc jeśli chcesz określić dokładność w sekundach, użyj CURRENT_DATE() i/lub CURRENT_TIME() zamiast tego.
 Przykład 4 – Dni i Tygodnie
 
 Istnieje wiele funkcji skalarnych ODBC, które zwracają określone części wartości daty. Te funkcje akceptują argument, który jest wyrażeniem daty, z którego wyodrębnia się żądaną część daty.
 
 Oto różne funkcje zwracania dni i tygodni od daty:
 DECLARE @date datetime2 ='2000-02-14 07:31:58.1234567';SELECT {fn DAYNAME(@data)} AS 'DAYNAME', {fn DAYOFYEAR(@date)} AS 'DAYOFYEAR', {fn DAYOFMONTH(@date)} AS 'DAYOFMONTH', {fn DAYOFWEEK(@date)} AS 'DAYOFWEEK', {fn WEEK(@date)} AS 'WEEK';
 
 Wynik:
 +-----------+-------------+-----------------+----- --------+--------+| NAZWA DNIA | DZIEŃROKU | DZIEŃ MIESIĄCA | DZIEŃ TYGODNIA | TYDZIEŃ ||-----------+-------------+--------------+------ -------+--------|| poniedziałek | 45 | 14 | 2 | 8 |+-----------+-------------+--------------+------ -------+--------+
 
 W tym przypadku przypisaliśmy datę do zmiennej, a następnie przekazaliśmy tę zmienną do każdej funkcji. Następnie funkcja zwróciła odpowiednią część daty.
 Przykład 5 – miesiące, kwartały i lata
 
 Oto różne funkcje zwracania miesięcy, kwartałów i lat z wartości daty/godziny:
 DECLARE @date datetime2 ='2000-02-14 07:31:58.1234567';SELECT {fn ROK(@data)} AS 'ROK', {fn MIESIĄC(@data)} AS 'MIESIĄC', {fn NAZWA MIESIĄCA(@data)} JAKO „NAZWA MIESIĄCA”, {fn KWARTAŁ(@data)} JAKO „KWARTAŁ”;
 
 Wynik:
 +---------+---------+-------------+------------+| ROK | MIESIĄC | NAZWA MIESIĄCA | KWARTAŁ ||--------+---------+-------------+------------|| 2000 | 2 | Luty | 1 |+--------+---------+-------------+-----------+
 Przykład 6 – godziny, minuty i sekundy
 
 Oto różne funkcje zwracania części godzin, minut i sekund z wartości daty/czasu:
 DECLARE @date datetime2 ='2000-02-14 07:31:58.1234567';SELECT {fn HOUR(@data)} AS 'HOUR', {fn MINUTE(@date)} AS 'MINUTE', {fn SECOND(@data)} JAKO „DRUGI”;
 
 Wynik:
 +--------+----------+----------+| GODZINA | MINUTA | DRUGIE ||--------+----------+----------|| 7 | 31 | 58 |+--------+----------+----------+
 Przykład 7 – Funkcja EXTRACT()
 
 Istnieje również funkcja skalarna ODBC o nazwie EXTRACT() , który umożliwia wyodrębnienie różnych części daty z wartości daty/godziny. Przykłady poniżej.
 Rok, miesiąc i dzień
 DECLARE @date datetime2 ='2000-02-14 07:31:58.1234567';SELECT {fn EXTRACT(ROK OD @data)} AS 'ROK', {fn EXTRACT(MIESIĄC OD @data)} AS 'MIESIĄC ', {fn EXTRACT(DZIEŃ OD @data)} JAK 'DZIEŃ';
 
 Wynik:
 +--------+---------+-------+| ROK | MIESIĄC | DZIEŃ ||--------+---------+-------|| 2000 | 2 | 14 |+--------+---------+-------+
 Godziny, minuty i sekundy
 DECLARE @date datetime2 ='2000-02-14 07:31:58.1234567';SELECT {fn EXTRACT(GODZINA OD @data)} AS 'GODZINA', {fn EXTRACT(MINUTA OD @data)} AS 'MINUTA ', {fn EXTRACT(DRUGA OD @data)} JAK 'DRUGA';
 
 Wynik:
 +--------+----------+----------+| GODZINA | MINUTA | DRUGIE ||--------+----------+----------|| 7 | 31 | 58 |+--------+----------+----------+
 Przykład 8 – Funkcja TIMESTAMPADD()
 
 TIMESTAMPADD() pozwala dodać określoną liczbę określonego interwału (część daty/czasu) do wartości daty/czasu. Ta funkcja przyjmuje trzy argumenty; interwał (część daty/godziny) do dodania (np. miesiąc), numer tej części do dodania i wartość daty. Przykłady poniżej.
 Rok, kwartał, miesiąc i dzień
 DECLARE @date datetime2 ='2000-02-14 07:31:58.1234567';SELECT {fn TIMESTAMPADD(SQL_TSI_YEAR, 21, @data)} AS 'SQL_TSI_YEAR', {fn TIMESTAMPADD(SQL_TSI_QUARTER, 21, @data) } AS 'SQL_TSI_QUARTER', {fn TIMESTAMPADD(SQL_TSI_MONTH, 21, @data)} AS 'SQL_TSI_MONTH', {fn TIMESTAMPADD(SQL_TSI_DAY, 21, @data)} AS 'SQL_TSI_DAY';
 
 Wynik:
 SQL_TSI_YEAR | 2021-02-14 07:31:58.1234567SQL_TSI_QUARTER | 2005-05-14 07:31:58.1234567SQL_TSI_MIESIĄC | 2001-11-14 07:31:58.1234567SQL_TSI_DAY | 2000-03-06 07:31:58.1234567
 Godziny, minuty i sekundy
 DECLARE @date datetime2 ='2000-02-14 07:31:58.1234567';SELECT {fn TIMESTAMPADD(SQL_TSI_HOUR, 5, @data)} AS 'SQL_TSI_HOUR', {fn TIMESTAMPADD(SQL_TSI_MINUTE, 5, @data) } AS 'SQL_TSI_MINUTE', {fn TIMESTAMPADD(SQL_TSI_SECOND, 5, @data)} AS 'SQL_TSI_SECOND', {fn TIMESTAMPADD(SQL_TSI_FRAC_SECOND, 5, @data)} AS 'SQL_TSI_FRAC_SECOND'; 
 Wynik:
 SQL_TSI_HOUR | 2000-02-14 12:31:58.1234567SQL_TSI_MINUTE | 2000-02-14 07:36:58.1234567SQL_TSI_SECOND | 2000-02-14 07:32:03.1234567SQL_TSI_FRAC_SECOND | 2000-02-14 07:31:58.1284567
 Przykład 9 – Funkcja TIMESTAMPDIFF()
 
 TIMESTAMPDIFF() funkcja zwraca różnicę między dwiema wartościami daty/czasu. Ta funkcja przyjmuje trzy argumenty; przedział (część daty/godziny), dla którego obliczana jest różnica (np. miesiąc), pierwsza data i druga data. Funkcja zwraca liczbę przedziałów, o które pierwsza data jest większa niż druga data. Przykłady poniżej.
 Rok, kwartał, miesiąc, tydzień i dzień
 DECLARE @date1 datetime2 ='2000-02-14 07:31:58.1234567'; DECLARE @date2 datetime2 =DATEADD(year, 1, @date1);SELECT {fn TIMESTAMPDIFF(SQL_TSI_YEAR, @date1, @date2)} AS 'SQL_TSI_YEAR', {fn TIMESTAMPDIFF(SQL_TSI_QUARTER, @date1, @date2)} AS 'SQL_TSI_QUAR ', {fn ZNACZNIK CZASU(SQL_TSI_MIESIĄC, @data1, @data2)} AS 'SQL_TSI_MIESIĄC', {fn ZNACZNIK CZASU(SQL_TSI_WEEK, @data1, @data2)} AS 'SQL_TSI_WEEK', {fn ZNACZNIK CZASU(@data1_dzień2), @data } JAKO 'SQL_TSI_DAY';
 
 Wynik:
 +----------------+-------------------+--------- --------+-----+---------------+| SQL_TSI_ROK | SQL_TSI_QUARTER | SQL_TSI_MONTH | SQL_TSI_WEEK | SQL_TSI_DAY ||----------------+------------------------+---------- -------+-----+---------------|| 1 | 4 | 12 | 52 | 366 |+----------------+-------------------+---------- -------+-----+---------------+
 Godziny, minuty i sekundy
 DECLARE @date1 datetime2 ='2000-02-14 07:31:58.1234567'; DECLARE @date2 datetime2 =DATEADD(day, 1, @date1);SELECT {fn TIMESTAMPDIFF(SQL_TSI_HOUR, @date1, @date2)} AS 'SQL_TSI_HOUR', {fn TIMESTAMPDIFF(SQL_TSI_MINUTE, @date1, @date2)} AS 'SQL_TSI_MINUTE ', {fn ZNACZNIK CZASOWY(SQL_TSI_SECOND, @data1, @data2)} AS 'SQL_TSI_SECOND', {fn ZNACZNIK CZASOWY(SQL_TSI_FRAC_SECOND, @data1, @data2)} JAKO 'SQL_TSI_FRAC_SECOND';
 
 Wynik:
 +----------------+------------------+---------- --------+-----------------------+| SQL_TSI_GODZINA | SQL_TSI_MINUTE | SQL_TSI_SECOND | SQL_TSI_FRAC_SECOND ||----------------+---------------------+----------- -------+------------------------|| 24 | 1440 | 86400 | 86400000 |+----------------+------------------+------------ -------+-----------------------+