Puede usar funciones escalares de ODBC al ejecutar instrucciones T-SQL en SQL Server. Hay varios tipos de funciones escalares ODBC, incluidas funciones de cadena, funciones numéricas, funciones del sistema y, por supuesto, funciones de fecha/hora (también denominadas funciones de fecha, hora e intervalo).
A continuación se muestran ejemplos de las funciones de fecha, hora e intervalo que puede utilizar en SQL Server.
Sintaxis
En primer lugar, esta es la sintaxis que debe usar siempre que llame a una función escalar ODBC:
SELECT {fn <function_name> [ (<argument>,....n) ] }
Donde <function_name> es el nombre de la función y (<argument>,....n) es cualquier número de argumentos opcionales.
Entonces, lo más importante que debe recordar es que cuando llama a una función escalar ODBC, debe encerrar la llamada a la función entre llaves ({} ) y el prefijo del nombre con fn .
Ejemplo 1:AHORA()
Esta función devuelve la fecha y la hora actuales como un valor de marca de tiempo.
SELECT {fn NOW()} AS Result; Resultado:
+-------------------------+ | Result | |-------------------------| | 2018-06-13 21:52:25.667 | +-------------------------+
Ejemplo 2:marca de tiempo, fecha y hora
El CURRENT_TIMESTAMP() La función devuelve la fecha local actual y la hora local como un valor de marca de tiempo. También puede usar el CURRENT_DATE() para devolver solo la parte de la fecha y/o CURRENT_TIME() para devolver solo la porción de tiempo.
SELECT
{fn CURRENT_TIMESTAMP()} AS 'Date & Time',
{fn CURRENT_DATE()} AS 'Date',
{fn CURRENT_TIME()} AS 'Time'; Resultado:
+-------------------------+------------+--------------+ | Date & Time | Date | Time | |-------------------------+------------+--------------| | 2018-06-13 21:57:29.197 | 2018-06-13 | 21:57:29.197 | +-------------------------+------------+--------------+
Además, CURRENT_TIMESTAMP() y CURRENT_TIME() ambos aceptan un argumento opcional para determinar la precisión en segundos del valor devuelto.
Ejemplos:
SELECT
{fn CURRENT_TIMESTAMP(3)} AS 'Date & Time',
{fn CURRENT_TIME(6)} AS 'Time'; Resultado:
+-------------------------+-----------------+ | Date & Time | Time | |-------------------------+-----------------| | 2018-06-13 22:00:59.263 | 22:00:59.263000 | +-------------------------+-----------------+
En este ejemplo, CURRENT_TIMESTAMP() devuelve una precisión de segundos de 3, mientras que CURRENT_TIME() devuelve una precisión de segundos de 6.
Ejemplo 3:CURDATE() y CURTIME()
Puedes usar CURDATE() y/o CURTIME() como alternativa a las funciones de fecha y hora anteriores:
SELECT
{fn CURDATE()} AS 'Date',
{fn CURTIME()} AS 'Time'; Resultado:
+------------+--------------+ | Date | Time | |------------+--------------| | 2018-06-13 | 22:05:20.013 | +------------+--------------+
Tenga en cuenta que estos argumentos no aceptan ningún argumento, por lo que si necesita especificar la precisión de los segundos, use CURRENT_DATE() y/o CURRENT_TIME() en su lugar.
Ejemplo 4:días y semanas
Hay un montón de funciones escalares de ODBC para devolver partes específicas de un valor de fecha. Estas funciones aceptan un argumento, que es la expresión de fecha para extraer la parte de fecha deseada.
Aquí están las diversas funciones para devolver la parte de días y semanas a partir de la fecha:
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'; Resultado:
+-----------+-------------+--------------+-------------+--------+ | DAYNAME | DAYOFYEAR | DAYOFMONTH | DAYOFWEEK | WEEK | |-----------+-------------+--------------+-------------+--------| | Monday | 45 | 14 | 2 | 8 | +-----------+-------------+--------------+-------------+--------+
En este caso, asignamos una fecha a una variable y luego pasamos esa variable a cada función. Luego, la función devolvió la parte de la fecha aplicable.
Ejemplo 5:meses, trimestres y años
Estas son las diversas funciones para devolver la parte de meses, trimestres y años del valor de fecha/hora:
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'; Resultado:
+--------+---------+-------------+-----------+ | YEAR | MONTH | MONTHNAME | QUARTER | |--------+---------+-------------+-----------| | 2000 | 2 | February | 1 | +--------+---------+-------------+-----------+
Ejemplo 6:horas, minutos y segundos
Estas son las diversas funciones para devolver la porción de horas, minutos y segundos del valor de fecha/hora:
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'; Resultado:
+--------+----------+----------+ | HOUR | MINUTE | SECOND | |--------+----------+----------| | 7 | 31 | 58 | +--------+----------+----------+
Ejemplo 7:la función EXTRAER()
También hay una función escalar ODBC llamada EXTRACT() , que le permite extraer las distintas partes de la fecha del valor de fecha/hora. Ejemplos a continuación.
Año, Mes y Día
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'; Resultado:
+--------+---------+-------+ | YEAR | MONTH | DAY | |--------+---------+-------| | 2000 | 2 | 14 | +--------+---------+-------+
Horas, minutos y segundos
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'; Resultado:
+--------+----------+----------+ | HOUR | MINUTE | SECOND | |--------+----------+----------| | 7 | 31 | 58 | +--------+----------+----------+
Ejemplo 8:la función TIMESTAMPADD()
El TIMESTAMPADD() le permite agregar un número específico del intervalo especificado (parte de fecha/hora) al valor de fecha/hora. Esta función acepta tres argumentos; el intervalo (parte de la fecha/hora) para agregar (por ejemplo, mes), el número de esa parte para agregar y el valor de la fecha. Ejemplos a continuación.
Año, Trimestre, Mes y Día
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'; Resultado:
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
Horas, minutos y segundos
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'; Resultado:
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
Ejemplo 9:la función TIMESTAMPDIFF()
El TIMESTAMPDIFF() La función devuelve la diferencia entre dos valores de fecha/hora. Esta función acepta tres argumentos; el intervalo (parte de fecha/hora) para el cual calcular la diferencia (por ejemplo, mes), la primera fecha y la segunda fecha. La función devuelve el número de intervalos en que la primera fecha es mayor que la segunda fecha Ejemplos a continuación.
Año, Trimestre, Mes, Semana y Día
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'; Resultado:
+----------------+-------------------+-----------------+----------------+---------------+ | SQL_TSI_YEAR | SQL_TSI_QUARTER | SQL_TSI_MONTH | SQL_TSI_WEEK | SQL_TSI_DAY | |----------------+-------------------+-----------------+----------------+---------------| | 1 | 4 | 12 | 52 | 366 | +----------------+-------------------+-----------------+----------------+---------------+
Horas, minutos y segundos
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'; Resultado:
+----------------+------------------+------------------+-----------------------+ | SQL_TSI_HOUR | SQL_TSI_MINUTE | SQL_TSI_SECOND | SQL_TSI_FRAC_SECOND | |----------------+------------------+------------------+-----------------------| | 24 | 1440 | 86400 | 86400000 | +----------------+------------------+------------------+-----------------------+
