U kunt ODBC scalaire functies gebruiken bij het uitvoeren van T-SQL-instructies in SQL Server. Er zijn verschillende soorten ODBC-scalarfuncties, waaronder tekenreeksfuncties, numerieke functies, systeemfuncties en natuurlijk datum-/tijdfuncties (ook wel datum-, tijd- en intervalfuncties genoemd).
Hieronder staan voorbeelden van de datum-, tijd- en intervalfuncties die u in SQL Server kunt gebruiken.
Syntaxis
Ten eerste, hier is de syntaxis die u moet gebruiken wanneer u een ODBC scalaire functie aanroept:
SELECT {fn [ (,....n) ] }
Waar <function_name> is de naam van de functie en (<argument>,....n) is een willekeurig aantal optionele argumenten.
Het belangrijkste om te onthouden is dat wanneer u een scalaire ODBC-functie aanroept, u de functie-aanroep tussen accolades moet plaatsen ({} ) en voeg de naam toe met fn .
Voorbeeld 1 – NU()
Deze functie retourneert de huidige datum en tijd als een tijdstempelwaarde.
SELECTEER {fn NOW()} ALS resultaat; Resultaat:
+-------------------------+| Resultaat ||-------------------------|| 2018-06-13 21:52:25.667 |+-------------------------+
Voorbeeld 2 – Tijdstempel, datum en tijd
De CURRENT_TIMESTAMP() functie retourneert de huidige lokale datum en lokale tijd als een tijdstempelwaarde. U kunt ook de CURRENT_DATE() . gebruiken om alleen het datumgedeelte terug te geven, en/of CURRENT_TIME() om alleen het tijdsgedeelte terug te geven.
SELECT {fn CURRENT_TIMESTAMP()} AS 'Datum &Tijd', {fn CURRENT_DATE()} AS 'Datum', {fn CURRENT_TIME()} AS 'Tijd'; Resultaat:
+-------------------------+------------+------- -------+| Datum &Tijd | Datum | Tijd ||-------------------------+------------+-------- ------|| 2018-06-13 21:57:29.197 | 2018-06-13 | 21:57:29.197 |+-------------------------+------------+---- ----------+
Ook CURRENT_TIMESTAMP() en CURRENT_TIME() beide accepteren een optioneel argument om de secondeprecisie van de geretourneerde waarde te bepalen.
Voorbeelden:
SELECT {fn CURRENT_TIMESTAMP(3)} AS 'Datum &Tijd', {fn CURRENT_TIME(6)} AS 'Tijd'; Resultaat:
+-------------------------+-----------------+| Datum &Tijd | Tijd ||-------------------------+-----------------|| 2018-06-13 22:00:59.263 | 22:00:59.263000 |+-------------------------+----------------- +
In dit voorbeeld CURRENT_TIMESTAMP() geeft een seconde precisie van 3 terug, terwijl CURRENT_TIME() geeft een nauwkeurigheid van 6 seconden terug.
Voorbeeld 3 – CURDATE() en CURTIME()
U kunt CURDATE() . gebruiken en/of CURTIME() als alternatief voor de bovenstaande datum- en tijdfuncties:
SELECTEER {fn CURDATE()} ALS 'Datum', {fn CURTIME()} ALS 'Tijd'; Resultaat:
+------------+--------------+| Datum | Tijd ||------------+--------------|| 2018-06-13 | 22:05:20.013 |+------------+--------------+
Houd er rekening mee dat deze argumenten geen argumenten accepteren, dus als u de secondeprecisie moet opgeven, gebruikt u CURRENT_DATE() en/of CURRENT_TIME() in plaats daarvan.
Voorbeeld 4 – Dagen en Weken
Er zijn een aantal scalaire ODBC-functies voor het retourneren van specifieke delen van een datumwaarde. Deze functies accepteren een argument, dat is de datumuitdrukking om het gewenste datumgedeelte uit te extraheren.
Hier zijn de verschillende functies voor het retourneren van de dagen en weken vanaf de datum:
DECLARE @date datetime2 ='2000-02-14 07:31:58.1234567';SELECT {fn DAYNAME(@date)} AS 'DAYNAME', {fn DAYOFYEAR(@date)} AS 'DAYOFYEAR', {fn DAYOFMONTH(@date)} ALS 'DAYOFMONTH', {fn DAYOFWEEK(@date)} ALS 'DAYOFWEEK', {fn WEEK(@date)} ALS 'WEEK'; Resultaat:
+-----------+-------------+--------------+----- --------+--------+| DAGNAAM | DAYOFYEAR | DAG VAN DE MAAND | DAG VAN DE WEEK | WEEK ||-----------+-------------+--------------+------ -------+--------|| maandag | 45 | 14 | 2 | 8 |+-----------+-------------+--------------+------ -------+--------+
In dit geval hebben we een datum aan een variabele toegewezen en die variabele vervolgens aan elke functie doorgegeven. De functie retourneerde vervolgens het toepasselijke datumgedeelte.
Voorbeeld 5 – Maanden, kwartalen en jaren
Hier zijn de verschillende functies voor het retourneren van de maanden, kwartalen en jaren vanaf de datum/tijd-waarde:
DECLARE @date datetime2 ='2000-02-14 07:31:58.1234567';SELECT {fn JAAR(@date)} ALS 'JAAR', {fn MAAND(@date)} ALS 'MAAND', {fn MONTHNAME(@date)} ALS 'MONTHNAME', {fn QUARTER(@date)} ALS 'QUARTER'; Resultaat:
+--------+---------+-------------+-----------+| JAAR | MAAND | MAANDNAAM | KWARTAAL ||--------+---------+-------------+-----------|| 2000 | 2 | februari | 1 |+--------+---------+-------------+-----------+
Voorbeeld 6 – Uren, minuten en seconden
Hier zijn de verschillende functies voor het retourneren van de uren, minuten en seconden van de datum/tijd-waarde:
DECLARE @date datetime2 ='2000-02-14 07:31:58.1234567';SELECT {fn HOUR(@date)} AS 'HOUR', {fn MINUTE(@date)} AS 'MINUTE', {fn TWEEDE(@date)} ALS 'TWEEDE'; Resultaat:
+--------+----------+----------+| UUR | MINUUT | TWEEDE ||--------+----------+----------|| 7 | 31 | 58 |+--------+----------+----------+
Voorbeeld 7 – De EXTRACT() Functie
Er is ook een ODBC scalaire functie genaamd EXTRACT() , waarmee u de verschillende datumdelen uit de datum/tijd-waarde kunt extraheren. Voorbeelden hieronder.
Jaar, maand en dag
DECLARE @date datetime2 ='2000-02-14 07:31:58.1234567';SELECT {fn EXTRACT(YEAR FROM @date)} AS 'YEAR', {fn EXTRACT(MONTH FROM @date)} AS 'MAAND ', {fn EXTRACT(DAY FROM @date)} ALS 'DAG'; Resultaat:
+--------+---------+-------+| JAAR | MAAND | DAG ||--------+---------+-------|| 2000 | 2 | 14 |+--------+---------+-------+
Uren, minuten en seconden
DECLARE @date datetime2 ='2000-02-14 07:31:58.1234567';SELECT {fn EXTRACT(HOUR FROM @date)} AS 'HOUR', {fn EXTRACT(MINUTE FROM @date)} AS 'MINUTE ', {fn EXTRACT(SECOND VAN @date)} ALS 'TWEEDE'; Resultaat:
+--------+----------+----------+| UUR | MINUUT | TWEEDE ||--------+----------+----------|| 7 | 31 | 58 |+--------+----------+----------+
Voorbeeld 8 – De functie TIMESTAMPADD()
De TIMESTAMPADD() stelt u in staat om een gespecificeerd aantal van het gespecificeerde interval (datum/tijd-gedeelte) toe te voegen aan de datum/tijd-waarde. Deze functie accepteert drie argumenten; het interval (datum/tijdgedeelte) dat moet worden opgeteld (bijv. maand), het nummer van dat gedeelte dat moet worden opgeteld en de datumwaarde. Voorbeelden hieronder.
Jaar, kwartaal, maand en dag
DECLARE @date datetime2 ='2000-02-14 07:31:58.1234567';SELECT {fn TIMESTAMPADD(SQL_TSI_YEAR, 21, @date)} AS 'SQL_TSI_YEAR', {fn TIMESTAMPADD(SQL_TSI_QUARTER, 21, @date) } AS 'SQL_TSI_QUARTER', {fn TIMESTAMPADD(SQL_TSI_MONTH, 21, @date)} AS 'SQL_TSI_MONTH', {fn TIMESTAMPADD(SQL_TSI_DAY, 21, @date)} ALS 'SQL_TSI_DAY'; Resultaat:
SQL_TSI_YEAR | 2021-02-14 07:31:58.1234567SQL_TSI_QUARTER | 2005-05-14 07:31:58.1234567SQL_TSI_MONTH | 2001-11-14 07:31:58.1234567SQL_TSI_DAY | 2000-03-06 07:31:58.1234567
Uren, minuten en seconden
DECLARE @date datetime2 ='2000-02-14 07:31:58.1234567';SELECT {fn TIMESTAMPADD(SQL_TSI_HOUR, 5, @date)} AS 'SQL_TSI_HOUR', {fn TIMESTAMPADD(SQL_TSI_MINUTE, 5, @date) } AS 'SQL_TSI_MINUTE', {fn TIMESTAMPADD(SQL_TSI_SECOND, 5, @date)} AS 'SQL_TSI_SECOND', {fn TIMESTAMPADD(SQL_TSI_FRAC_SECOND, 5, @date)} ALS 'SQL_TSI_FRACpre_SEC>
Resultaat:
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
Voorbeeld 9 – De functie TIMESTAMPDIFF()
De TIMESTAMPDIFF() functie retourneert het verschil tussen twee datum/tijd-waarden. Deze functie accepteert drie argumenten; het interval (datum/tijdgedeelte) waarvoor het verschil moet worden berekend (bijv. maand), de eerste datum en de tweede datum. De functie retourneert het aantal intervallen dat de eerste datum groter is dan de tweede datum Voorbeelden hieronder.
Jaar, kwartaal, maand, week en dag
VERKLAREN @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 'SQARTER ', {fn TIMESTAMPDIFF(SQL_TSI_MONTH, @date1, @date2)} ALS 'SQL_TSI_MONTH', {fn TIMESTAMPDIFF(SQL_TSI_WEEK, @date1, @date2)} AS 'SQL_TSI_WEEK', {fn TIMESTAMPDI1,_date2), @QL_date } AS 'SQL_TSI_DAY';
Resultaat:
+----------------+-------------------+--------- --------+----------------+---------------+| SQL_TSI_YEAR | SQL_TSI_QUARTER | SQL_TSI_MONTH | SQL_TSI_WEEK | SQL_TSI_DAY ||----------------+-------------------+---------- -------+----------------+---------------|| 1 | 4 | 12 | 52 | 366 |+----------------+-------------------+---------- -------+----------------+---------------+
Uren, minuten en seconden
VERKLAREN @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)TSI ALS 'SQL_ ', {fn TIMESTAMPDIFF(SQL_TSI_SECOND, @date1, @date2)} AS 'SQL_TSI_SECOND', {fn TIMESTAMPDIFF(SQL_TSI_FRAC_SECOND, @date1, @date2)} AS 'SQL_TSI_FRAC_SECOND';
Resultaat:
+----------------+------------------+---------- --------+-----------------------+| SQL_TSI_HOUR | SQL_TSI_MINUTE | SQL_TSI_SECOND | SQL_TSI_FRAC_SECOND ||----------------+------------------+----------- -------+-----------------------|| 24 | 1440 | 86400 | 86400000 |+----------------+------------------+----------- -------+-----------------------+