Convertir 'time' en 'datetime2' dans SQL Server (exemples T-SQL)

Cet article contient des exemples de conversion d'une heure valeur à un datetime2 valeur dans SQL Server.

Lorsque vous convertissez une heure valeur à datetime2 , des informations supplémentaires sont ajoutées à la valeur. C'est parce que le datetime2 Le type de données contient à la fois des informations de date et d'heure. Le temps Le type de données, en revanche, ne contient que des informations temporelles.

Plus précisément, la date est définie sur '1900-01-01' (à moins qu'elle ne soit arrondie à '1900-01-02'), le composant horaire est copié et, selon la documentation Microsoft, le fuseau horaire décalage est défini sur 00:00 (même si le datetime2 le type de données ne tient pas compte du fuseau horaire et ne conserve aucun décalage de fuseau horaire).

Lorsque la précision en fractions de seconde de datetime2(n) la valeur est supérieure à time(n) valeur, la valeur est arrondie.

Exemple 1 - Conversion explicite à l'aide de CAST()

Voici un exemple de conversion explicite. Dans ce cas, j'utilise le CAST() fonction directement dans le SELECT déclaration pour convertir explicitement à partir de temps à datetime2 .

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

Résultat :

+------------------+--------------------------- --+| temps | dateheure2 ||------------------+----------------------- -|| 23:15:59.0040070 | 1900-01-01 23:15:59.0040070 |+------------------+-------------------- ----------+

Lorsque vous convertissez à partir de temps à datetime2 , un composant de date est ajouté et défini sur 1900-01-01 .

Cependant, il existe des scénarios où la date pourrait être arrondie à 1900-01-02 . Cela dépendra des fractions de seconde et de la précision que vous utilisez. Voir ci-dessous pour un exemple de ceci.

Exemple 2 - Précision fractionnaire de seconde

Vous pouvez obtenir des résultats différents en fonction de la précision en fractions de seconde attribuée à chaque type de données. Cela dépendra de la valeur réelle de la partie fractionnaire.

Dans l'exemple précédent, les deux types de données utilisaient la même précision en fractions de seconde. C'est parce que je n'ai pas spécifié d'échelle (pour définir leur précision) et donc ils ont tous deux utilisé leurs valeurs d'échelle par défaut (les deux se trouvent être 7).

Juste pour être clair, échelle est le nombre de chiffres à droite de la virgule décimale dans un nombre. Précision est le nombre total de chiffres du nombre.

Quoi qu'il en soit, dans cet exemple, je n'ai attribué que 6 décimales à la valeur initiale, par conséquent, un zéro est ajouté à la fin.

Voici ce qui se passe si je spécifie une plus grande précision pour le temps valeur par rapport à la datetime2 valeur :

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

 Résultat :
 
+------------------+--------------------------+ | temps | dateheure2(4) ||------------------+------------------------- -|| 23:15:59.1234567 | 1900-01-01 23:15:59.1235 |+------------------+-------------------- -------+
 

 En spécifiant une échelle de 4 au datetime2 valeur, le résultat est réduit à 4 décimales, et dans ce cas il est arrondi. 
 

 Comme vous vous en doutez, ce n'est pas seulement la partie fractionnaire qui peut être arrondie. Voici un exemple où la partie fractionnaire entraîne l'arrondi des minutes et des secondes :
 
DECLARE @thetime time(7);SET @thetime ='23:15:59.7654321';SELECT @thetime AS 'time', CAST(@thetime AS datetime2(0)) AS 'datetime2(0)'; 

 Résultat :
 
+-------------+---------------------+| temps | dateheure2(0) ||-------------+---------------------|| 23:15:59.7654321 | 1900-01-01 23:16:00 |+-----------------+------------------- --+
 

 Cependant, vous pouvez obtenir des résultats différents pour les mêmes données en modifiant la précision. Si nous augmentons la précision, ne serait-ce que d'une décimale, nous obtenons ceci :
 
DECLARE @thetime time(7);SET @thetime ='23:15:59.7654321';SELECT @thetime AS 'time', CAST(@thetime AS datetime2(1)) AS 'datetime2(1)'; 

 Résultat :
 
+------------------+-----------------------+| temps | dateheure2(1) ||-------------+----------------------|| 23:15:59.7654321 | 1900-01-01 23:15:59.8 |+------------------+------------------- ----+
 

 Donc, dans ce cas, les minutes et les secondes n'étaient pas arrondi (mais les millisecondes étaient ).
 

 Voici ce qui se passe si je règle l'heure valeur pour utiliser une échelle de précision inférieure à datetime2 valeur. 
 
DECLARE @thetime time(0);SET @thetime ='23:15:59.004007';SELECT @thetime AS 'time', CAST(@thetime AS datetime2) AS 'datetime2';
 

 Résultat :
 
+----------+--------------------------------------+| temps | dateheure2 ||----------+--------------------------------------|| 23:15:59 | 1900-01-01 23:15:59.0000000 |+----------+----------------------------------- --+
 

 Et pendant que nous y sommes, voici un exemple où notre échelle de précision peut entraîner des fractions de seconde provoquant l'arrondi de la date au jour suivant :
 
DECLARE @thetime time(7);SET @thetime ='23:59:59.9999999';SELECT @thetime AS 'time', CAST(@thetime AS datetime2(0)) AS 'datetime2(0)'; 

 Résultat :
 
+-------------+---------------------+| temps | dateheure2(0) ||-------------+---------------------|| 23:59:59.9999999 | 1900-01-02 00:00:00 |+-----------------+------------------- --+
 
Exemple 3 - Conversion explicite à l'aide de CONVERT()
 

 C'est le même que le premier exemple, sauf que cette fois j'utilise le CONVERT() fonction au lieu de CAST() . 
 
DECLARE @thetime time;SET @thetime ='23:15:59.004007';SELECT @thetime AS 'time', CONVERT(datetime2, @thetime) AS 'datetime2';
 

 Résultat :
 
+------------------+--------------------------- --+| temps | dateheure2 ||------------------+----------------------- -|| 23:15:59.0040070 | 1900-01-01 23:15:59.0040070 |+------------------+-------------------- ----------+
 
Exemple 4 – Conversion implicite
 

 Voici un exemple de faire la même chose, mais en utilisant une conversion de type implicite. 
 
DECLARE @thetime time, @thedatetime2 datetime2;SET @thetime ='23:15:59.004007';SET @thedatetime2 =@thetime;SELECT @thetime AS 'time', @thedatetime2 AS 'datetime2';
 

 Résultat :
 
+------------------+--------------------------- --+| temps | dateheure2 ||------------------+----------------------- -|| 23:15:59.0040070 | 1900-01-01 23:15:59.0040070 |+------------------+-------------------- ----------+
 

 Nous obtenons donc le même résultat, qu'il s'agisse d'une conversion explicite ou implicite.
 

 Il s'agit d'une conversion implicite car nous n'utilisons pas de fonction de conversion pour la convertir explicitement. Nous attribuons simplement la valeur d'une variable d'un type de données à une variable d'un autre type de données. Dans ce cas, SQL Server effectue une conversion implicite dans les coulisses lorsque nous essayons d'attribuer l'heure valeur à un datetime2 variables.
 
Exemple 5 - Modifier la date
 

 Si vous devez changer la date (mais garder la même heure), vous pouvez utiliser le DATEADD() une fonction. 
 
DECLARE @thetime time, @thedatetime2 datetime2;SET @thetime ='23:15:59.004007';SET @thedatetime2 =@thetime;SET @thedatetime2 =DATEADD(year, 120, @thedatetime2);SELECT @thetime AS ' heure', @thedatetime2 AS 'datetime2';
 

 Résultat :
 
+------------------+--------------------------- --+| temps | dateheure2 ||------------------+----------------------- -|| 23:15:59.0040070 | 2020-01-01 23:15:59.0040070 |+------------------+-------------------- ----------+
 

 Dans ce cas, j'ajoute 120 à la valeur de l'année, ce qui l'amène à 2020.