Convierta 'hora' en 'datetimeoffset' en SQL Server (ejemplos de T-SQL)

Este artículo contiene ejemplos de cómo convertir una hora valor a un datetimeoffset valor en SQL Server mediante Transact-SQL.

Cuando conviertes una hora valor a datetimeoffset , la fecha se establece en '1900-01-01' y se copia la hora. Se agrega un desplazamiento de zona horaria y se establece en +00:00.

Ejemplo 1:conversión explícita mediante CAST()

Este es un ejemplo de una conversión explícita. En este caso, uso el CAST() función directamente dentro del SELECT declaración para convertir explícitamente de tiempo a datetimeoffset .

DECLARE @thetime time;
SET @thetime = '23:15:59.1234567';
SELECT 
  @thetime AS 'time',
  CAST(@thetime AS datetimeoffset) AS 'datetimeoffset';

Resultado:

+------------------+------------------------------------+
| time             | datetimeoffset                     |
|------------------+------------------------------------|
| 23:15:59.1234567 | 1900-01-01 23:15:59.1234567 +00:00 |
+------------------+------------------------------------+

Entonces, se agrega una parte de la fecha y se establece en '1900-01-01', se copia la hora y se agrega un desplazamiento de zona horaria y se establece en +00:00.

Ejemplo 2:precisión

En el ejemplo anterior, ambos tipos de datos usan su precisión/escala predeterminada (7). Esto se debe a que no agregué una escala entre paréntesis (la escala determina la precisión de las fracciones de segundo). Al usar una escala de 7, podemos ver que ambos tipos de datos pueden representar un valor de tiempo con una precisión de 7 decimales.

En otras palabras, cuando configuré inicialmente @thetime variable, incluí 7 lugares decimales en el valor (específicamente, 1234567 ). Tanto el tipo de datos 'time' como 'datetimeoffset' pudieron representarlos con éxito porque ambos usaron una escala de 7. Nuevamente, sabemos que usaron 7 porque ese es el valor predeterminado.

Para que quede claro, escala es el número de dígitos a la derecha del punto decimal en un número. Precisión es el número total de dígitos en el número.

Podemos reducir la precisión de fracciones de segundo si es necesario.

Estos son algunos ejemplos que demuestran lo que sucede cuando los tipos de datos se configuran para usar una precisión de segundos fraccionarios diferente:

DECLARE @thetime time(7);
SET @thetime = '23:15:59.1234567';
SELECT 
  @thetime AS 'time',
  CAST(@thetime AS datetimeoffset(0)) AS 'datetimeoffset';

Resultado:

+------------------+------------------------------------+
| time             | datetimeoffset                     |
|------------------+------------------------------------|
| 23:15:59.1234567 | 1900-01-01 23:15:59.0000000 +00:00 |
+------------------+------------------------------------+

En este caso, configuro explícitamente el @thetime variable para usar una escala de 7. Pero cuando lanzo esto a datetimeoffset , puse la escala en 0. Por lo tanto, el resultado de datetimeoffset el valor es menor precisión de segundos fraccionarios. En mi sistema, todavía se muestran 7 lugares decimales, pero todos son 0.

Aquí está de nuevo, pero esta vez aumento la precisión de las fracciones de segundo a 3 para el datetimeoffset valor:

DECLARE @thetime time(7);
SET @thetime = '23:15:59.1234567';
SELECT 
  @thetime AS 'time',
  CAST(@thetime AS datetimeoffset(3)) AS 'datetimeoffset';

Resultado:

+------------------+------------------------------------+
| time             | datetimeoffset                     |
|------------------+------------------------------------|
| 23:15:59.1234567 | 1900-01-01 23:15:59.1230000 +00:00 |
+------------------+------------------------------------+

Entonces usa los primeros 3 segundos fraccionarios (milisegundos).

Sin embargo, si aumentamos la precisión de las fracciones de segundo a 4, mira lo que sucede:

DECLARE @thetime time(7);
SET @thetime = '23:15:59.1234567';
SELECT 
  @thetime AS 'time',
  CAST(@thetime AS datetimeoffset(4)) AS 'datetimeoffset';

Resultado:

+------------------+------------------------------------+
| time             | datetimeoffset                     |
|------------------+------------------------------------|
| 23:15:59.1234567 | 1900-01-01 23:15:59.1235000 +00:00 |
+------------------+------------------------------------+

En el siguiente ejemplo, aumento el valor de la parte fraccionaria para que cause la parte no fraccionaria de datetimeoffset valor a redondear:

DECLARE @thetime time(7);
SET @thetime = '23:15:59.7654321';
SELECT 
  @thetime AS 'time',
  CAST(@thetime AS datetimeoffset(0)) AS 'datetimeoffset';

Resultado:

+------------------+------------------------------------+
| time             | datetimeoffset                     |
|------------------+------------------------------------|
| 23:15:59.7654321 | 1900-01-01 23:16:00.0000000 +00:00 |
+------------------+------------------------------------+

En este caso, los minutos se redondearon y los segundos se pusieron a cero.

Cambiémoslo para que datetimeoffset tiene una precisión mayor que el tiempo valor:

DECLARE @thetime time(4);
SET @thetime = '23:15:59.1234567';
SELECT 
  @thetime AS 'time',
  CAST(@thetime AS datetimeoffset(7)) AS 'datetimeoffset';

Resultado:

+------------------+------------------------------------+
| time             | datetimeoffset                     |
|------------------+------------------------------------|
| 23:15:59.1235000 | 1900-01-01 23:15:59.1235000 +00:00 |
+------------------+------------------------------------+

Declaré el @thetime variable para usar una escala de 4, pero luego usó una escala de 7 al convertirla a datetimeoffset tipo de datos. No es necesario usar una precisión de 7, ya que no puede usar una precisión mayor que la que ya se asignó.

Además, cualquier redondeo de menor precisión ya se ha producido en el momento en que se convierte a (mayor precisión) datetimeoffset tipo de datos. Observe que el tiempo el tipo de datos redondeó los segundos fraccionarios desde el valor inicial que le asigné. Este efecto de redondeo también se transmitió al datetimeoffset valor.

Ejemplo 3:conversión explícita mediante CONVERT()

Aquí hay un ejemplo usando CONVERT() función en lugar de CAST() .

DECLARE @thetime time;
SET @thetime = '23:15:59.1234567';
SELECT 
  @thetime AS 'time',
  CONVERT(datetimeoffset, @thetime) AS 'datetimeoffset';

Resultado:

+------------------+------------------------------------+
| time             | datetimeoffset                     |
|------------------+------------------------------------|
| 23:15:59.1234567 | 1900-01-01 23:15:59.1234567 +00:00 |
+------------------+------------------------------------+

Ejemplo 4:conversión implícita

Aquí hay un ejemplo de hacer lo mismo, pero usando una conversión de tipo implícita.

DECLARE @thetime time, @thedatetimeoffset datetimeoffset;
SET @thetime = '23:15:59.1234567';
SET @thedatetimeoffset = @thetime;
SELECT 
  @thetime AS 'time',
  @thedatetimeoffset AS 'datetimeoffset';

Resultado:

+------------------+------------------------------------+
| time             | datetimeoffset                     |
|------------------+------------------------------------|
| 23:15:59.1234567 | 1900-01-01 23:15:59.1234567 +00:00 |
+------------------+------------------------------------+

Entonces obtenemos el mismo resultado, independientemente de si se trata de una conversión explícita o implícita.

Esta es una conversión implícita porque no estamos usando una función de conversión para convertirla explícitamente. Simplemente estamos asignando el valor de una variable de un tipo de datos a una variable de otro tipo de datos. En este caso, SQL Server realiza una conversión implícita entre bastidores cuando intentamos asignar la hora valor a un datetimeoffset variables.

Ejemplo 5:cambiar la fecha

Si necesita cambiar la fecha (pero mantener la misma hora), puede usar DATEADD() función.

DECLARE @thetime time, @thedatetimeoffset datetimeoffset;
SET @thetime = '23:15:59.1234567';
SET @thedatetimeoffset = @thetime;
SET @thedatetimeoffset = DATEADD(year, 285, @thedatetimeoffset);
SELECT 
  @thetime AS 'time',
  @thedatetimeoffset AS 'datetimeoffset';

Resultado:

+------------------+------------------------------------+
| time             | datetimeoffset                     |
|------------------+------------------------------------|
| 23:15:59.1234567 | 2185-01-01 23:15:59.1234567 +00:00 |
+------------------+------------------------------------+

En este caso, agrego 285 al valor del año, lo que lo lleva a 2185.