È possibile utilizzare le funzioni scalari ODBC durante l'esecuzione di istruzioni T-SQL in SQL Server. Esistono vari tipi di funzioni scalari ODBC, incluse funzioni di stringa, funzioni numeriche, funzioni di sistema e, naturalmente, funzioni di data/ora (indicate anche come funzioni di data, ora e intervallo).
Di seguito sono riportati esempi delle funzioni di data, ora e intervallo che è possibile utilizzare in SQL Server.
Sintassi
Innanzitutto, ecco la sintassi che devi utilizzare ogni volta che chiami una funzione scalare ODBC:
SELECT {fn <function_name> [ (<argument>,....n) ] }
Dove <function_name> è il nome della funzione e (<argument>,....n) è un numero qualsiasi di argomenti facoltativi.
Quindi la cosa principale da ricordare è che quando chiami una funzione scalare ODBC, devi racchiudere la chiamata di funzione tra parentesi graffe ({} ) e anteporre al nome fn .
Esempio 1 – ADESSO()
Questa funzione restituisce la data e l'ora correnti come valore di timestamp.
SELECT {fn NOW()} AS Result; Risultato:
+-------------------------+ | Result | |-------------------------| | 2018-06-13 21:52:25.667 | +-------------------------+
Esempio 2:timestamp, data e ora
Il CURRENT_TIMESTAMP() La funzione restituisce la data e l'ora locali correnti come valore di timestamp. Puoi anche usare il CURRENT_DATE() per restituire solo la parte della data e/o CURRENT_TIME() restituire solo la parte di tempo.
SELECT
{fn CURRENT_TIMESTAMP()} AS 'Date & Time',
{fn CURRENT_DATE()} AS 'Date',
{fn CURRENT_TIME()} AS 'Time'; Risultato:
+-------------------------+------------+--------------+ | Date & Time | Date | Time | |-------------------------+------------+--------------| | 2018-06-13 21:57:29.197 | 2018-06-13 | 21:57:29.197 | +-------------------------+------------+--------------+
Inoltre, CURRENT_TIMESTAMP() e CURRENT_TIME() entrambi accettano un argomento facoltativo per determinare la precisione in secondi del valore restituito.
Esempi:
SELECT
{fn CURRENT_TIMESTAMP(3)} AS 'Date & Time',
{fn CURRENT_TIME(6)} AS 'Time'; Risultato:
+-------------------------+-----------------+ | Date & Time | Time | |-------------------------+-----------------| | 2018-06-13 22:00:59.263 | 22:00:59.263000 | +-------------------------+-----------------+
In questo esempio, CURRENT_TIMESTAMP() restituisce una precisione di 3 secondi, mentre CURRENT_TIME() restituisce una precisione di 6 secondi.
Esempio 3 – CURDATE() e CURTIME()
Puoi usare CURDATE() e/o CURTIME() in alternativa alle suddette funzioni di data e ora:
SELECT
{fn CURDATE()} AS 'Date',
{fn CURTIME()} AS 'Time'; Risultato:
+------------+--------------+ | Date | Time | |------------+--------------| | 2018-06-13 | 22:05:20.013 | +------------+--------------+
Tieni presente che questi argomenti non accettano alcun argomento, quindi se devi specificare la precisione dei secondi, utilizza CURRENT_DATE() e/o CURRENT_TIME() invece.
Esempio 4 – Giorni e settimane
Esistono numerose funzioni scalari ODBC per restituire parti specifiche di un valore di data. Queste funzioni accettano un argomento, che è l'espressione di data da cui estrarre la parte di data desiderata.
Ecco le varie funzioni per restituire i giorni e le settimane a partire dalla data:
DECLARE @date datetime2 = '2000-02-14 07:31:58.1234567';
SELECT
{fn DAYNAME(@date)} AS 'DAYNAME',
{fn DAYOFYEAR(@date)} AS 'DAYOFYEAR',
{fn DAYOFMONTH(@date)} AS 'DAYOFMONTH',
{fn DAYOFWEEK(@date)} AS 'DAYOFWEEK',
{fn WEEK(@date)} AS 'WEEK'; Risultato:
+-----------+-------------+--------------+-------------+--------+ | DAYNAME | DAYOFYEAR | DAYOFMONTH | DAYOFWEEK | WEEK | |-----------+-------------+--------------+-------------+--------| | Monday | 45 | 14 | 2 | 8 | +-----------+-------------+--------------+-------------+--------+
In questo caso, abbiamo assegnato una data a una variabile, quindi abbiamo passato quella variabile a ciascuna funzione. La funzione ha quindi restituito la parte della data applicabile.
Esempio 5:mesi, trimestri e anni
Ecco le varie funzioni per restituire la parte di mesi, trimestri e anni dal valore di data/ora:
DECLARE @date datetime2 = '2000-02-14 07:31:58.1234567';
SELECT
{fn YEAR(@date)} AS 'YEAR',
{fn MONTH(@date)} AS 'MONTH',
{fn MONTHNAME(@date)} AS 'MONTHNAME',
{fn QUARTER(@date)} AS 'QUARTER'; Risultato:
+--------+---------+-------------+-----------+ | YEAR | MONTH | MONTHNAME | QUARTER | |--------+---------+-------------+-----------| | 2000 | 2 | February | 1 | +--------+---------+-------------+-----------+
Esempio 6:ore, minuti e secondi
Ecco le varie funzioni per restituire la parte di ore, minuti e secondi dal valore di data/ora:
DECLARE @date datetime2 = '2000-02-14 07:31:58.1234567';
SELECT
{fn HOUR(@date)} AS 'HOUR',
{fn MINUTE(@date)} AS 'MINUTE',
{fn SECOND(@date)} AS 'SECOND'; Risultato:
+--------+----------+----------+ | HOUR | MINUTE | SECOND | |--------+----------+----------| | 7 | 31 | 58 | +--------+----------+----------+
Esempio 7 – La funzione EXTRACT()
C'è anche una funzione scalare ODBC chiamata EXTRACT() , che consente di estrarre le varie parti di data dal valore di data/ora. Esempi sotto.
Anno, mese e giorno
DECLARE @date datetime2 = '2000-02-14 07:31:58.1234567';
SELECT
{fn EXTRACT(YEAR FROM @date)} AS 'YEAR',
{fn EXTRACT(MONTH FROM @date)} AS 'MONTH',
{fn EXTRACT(DAY FROM @date)} AS 'DAY'; Risultato:
+--------+---------+-------+ | YEAR | MONTH | DAY | |--------+---------+-------| | 2000 | 2 | 14 | +--------+---------+-------+
Ore, minuti e secondi
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 FROM @date)} AS 'SECOND'; Risultato:
+--------+----------+----------+ | HOUR | MINUTE | SECOND | |--------+----------+----------| | 7 | 31 | 58 | +--------+----------+----------+
Esempio 8 – La funzione TIMESTAMPADD()
Il TIMESTAMPADD() consente di aggiungere un numero specificato dell'intervallo specificato (parte data/ora) al valore di data/ora. Questa funzione accetta tre argomenti; l'intervallo (parte data/ora) da aggiungere (ad es. mese), il numero di quella parte da aggiungere e il valore della data. Esempi sotto.
Anno, trimestre, mese e giorno
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)} AS 'SQL_TSI_DAY'; Risultato:
SQL_TSI_YEAR | 2021-02-14 07:31:58.1234567 SQL_TSI_QUARTER | 2005-05-14 07:31:58.1234567 SQL_TSI_MONTH | 2001-11-14 07:31:58.1234567 SQL_TSI_DAY | 2000-03-06 07:31:58.1234567
Ore, minuti e secondi
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)} AS 'SQL_TSI_FRAC_SECOND'; Risultato:
SQL_TSI_HOUR | 2000-02-14 12:31:58.1234567 SQL_TSI_MINUTE | 2000-02-14 07:36:58.1234567 SQL_TSI_SECOND | 2000-02-14 07:32:03.1234567 SQL_TSI_FRAC_SECOND | 2000-02-14 07:31:58.1284567
Esempio 9 – La funzione TIMESTAMPDIFF()
Il TIMESTAMPDIFF() La funzione restituisce la differenza tra due valori di data/ora. Questa funzione accetta tre argomenti; l'intervallo (parte data/ora) per il quale calcolare la differenza (es. mese), la prima data e la seconda data. La funzione restituisce il numero di intervalli in cui la prima data è maggiore della seconda data Esempi di seguito.
Anno, trimestre, mese, settimana e giorno
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_QUARTER',
{fn TIMESTAMPDIFF(SQL_TSI_MONTH, @date1, @date2)} AS 'SQL_TSI_MONTH',
{fn TIMESTAMPDIFF(SQL_TSI_WEEK, @date1, @date2)} AS 'SQL_TSI_WEEK',
{fn TIMESTAMPDIFF(SQL_TSI_DAY, @date1, @date2)} AS 'SQL_TSI_DAY'; Risultato:
+----------------+-------------------+-----------------+----------------+---------------+ | SQL_TSI_YEAR | SQL_TSI_QUARTER | SQL_TSI_MONTH | SQL_TSI_WEEK | SQL_TSI_DAY | |----------------+-------------------+-----------------+----------------+---------------| | 1 | 4 | 12 | 52 | 366 | +----------------+-------------------+-----------------+----------------+---------------+
Ore, minuti e secondi
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 TIMESTAMPDIFF(SQL_TSI_SECOND, @date1, @date2)} AS 'SQL_TSI_SECOND',
{fn TIMESTAMPDIFF(SQL_TSI_FRAC_SECOND, @date1, @date2)} AS 'SQL_TSI_FRAC_SECOND'; Risultato:
+----------------+------------------+------------------+-----------------------+ | SQL_TSI_HOUR | SQL_TSI_MINUTE | SQL_TSI_SECOND | SQL_TSI_FRAC_SECOND | |----------------+------------------+------------------+-----------------------| | 24 | 1440 | 86400 | 86400000 | +----------------+------------------+------------------+-----------------------+
