Sqlserver
 sql >> Base de données >  >> RDS >> Sqlserver

Différentes manières d'utiliser la fonction de date SQL CONVERT

Dans cet article, nous explorerons l'utilisation des différents formats de date SQL CONVERT dans SQL Server.

L'interprétation de la date varie d'un pays à l'autre. Supposons que vous disposiez d'une base de données SQL Server globale avec une table contenant un format de date spécifique. Par exemple, il a une colonne de date qui a la valeur 01/05/2020.

Comment l'interprétez-vous ? Examinons les interprétations suivantes dans différents pays.

  • États-Unis :5 janvier 2020 (format standard :mm/jj/aaaa)
  • Europe :1er mai 2020 (format standard :jj/mm/aaaa)

De plus, d'autres pays utilisent des formats de date différents :

  • Turquie :jj.mm.aaaa
  • Inde :jj-mm-aaaa
  • Bulgarie :aaaa-m-j
  • Hongrie :aaaa.mm.jj.

Vous pouvez consulter Wikipédia pour plus d'informations sur les formats de date par pays.

En dehors de cela, nous souhaitons parfois inclure l'horodatage avec les dates. Voici quelques exemples :

  • 05/01/2020 10:00
  • 05/05/2020 14:00
  • 05/05/2020 14:00
  • 05/01/2020 02:00:55

Il n'est pas possible de stocker des dates dans une table SQL Server dans différents formats, nous avons donc besoin d'un moyen de convertir les formats de date. Explorons les différentes méthodes de format de date SQL CONVERT.

Fonction SQL CONVERT date

Généralement, les professionnels des bases de données utilisent la fonction de date SQL CONVERT pour obtenir des dates dans un format spécifié et cohérent. Cela applique les codes de style pour des dates de sortie spécifiques.

Syntaxe de la fonction CONVERT() :

CONVERT(type de données, datetime [,style])

Dans la requête SQL ci-dessous, nous convertissons la date et l'heure en deux formats à l'aide de la fonction CONVERT().

  • format mm/jj/aa :code de style 1
  • format jj/mm/aaaa :code de style 101
DECLARE @Inputdate datetime = '2019-12-31 14:43:35.863';
Select CONVERT(varchar,@Inputdate,1) as [mm/dd/yy],
CONVERT(varchar,@Inputdate,101) as [mm/dd/yyyy]

De même, nous pouvons spécifier différents codes de style afin que vous puissiez convertir les dates dans le format requis.

SELECT '0' AS [StyleCode],
'Default format' AS [Standard and Format],
CONVERT(VARCHAR(50), Getdate(), 0) AS [OutputFormat]
UNION ALL
SELECT '1' AS [StyleCode],
'USA - mm/dd/yy' AS [Standard and Format],
CONVERT(VARCHAR(50), Getdate(), 1) AS [OutputFormat]
UNION ALL
SELECT '2' AS [StyleCode],
'ANSI - dd.mm.yy' AS [Standard and Format],
CONVERT(VARCHAR(50), Getdate(), 2) AS [OutputFormat]
UNION ALL
SELECT '3' AS [StyleCode],
'British and French - dd/mm/yy' AS [Standard and Format],
CONVERT(VARCHAR(50), Getdate(), 3) AS [OutputFormat]
UNION ALL
SELECT '4' AS [StyleCode],
'German - dd.mm.yy' AS [Standard and Format],
CONVERT(VARCHAR(50), Getdate(), 4) AS [OutputFormat]
UNION ALL
SELECT '5' AS [StyleCode],
'Italian - dd-mm-yy ' AS [Standard and Format],
CONVERT(VARCHAR(50), Getdate(), 5) AS [OutputFormat]
UNION ALL
SELECT '6' AS [StyleCode],
'Shortened month name -dd mon yy' AS [Standard and Format],
CONVERT(VARCHAR(50), Getdate(), 6) AS [OutputFormat]
UNION ALL
SELECT '7' AS [StyleCode],
'Shortened month name - mon dd, yy' AS [Standard and Format],
CONVERT(VARCHAR(50), Getdate(), 7) AS [OutputFormat]
UNION ALL
SELECT '8' AS [StyleCode],
'24 hour time -hh:mm:ss' AS [Standard and Format],
CONVERT(VARCHAR(50), Getdate(), 8) AS [OutputFormat]
UNION ALL
SELECT '9' AS [StyleCode],
'Default + milliseconds - mon dd yyyy hh:mm:ss:mmmAM (or PM)' AS
[Standard and Format],
CONVERT(VARCHAR(50), Getdate(), 9) AS [OutputFormat]
UNION ALL
SELECT '10' AS [StyleCode],
'USA - mm-dd-yy' AS [Standard and Format],
CONVERT(VARCHAR(50), Getdate(), 10) AS [OutputFormat]
UNION ALL
SELECT '11' AS [StyleCode],
'Japan -yy/mm/dd' AS [Standard and Format],
CONVERT(VARCHAR(50), Getdate(), 11) AS [OutputFormat]
UNION ALL
SELECT '12' AS [StyleCode],
'ISO format -yymmdd' AS [Standard and Format],
CONVERT(VARCHAR(50), Getdate(), 12) AS [OutputFormat]
UNION ALL
SELECT '13' AS [StyleCode],
'Europe default + milliseconds -dd mon yyyy hh:mm:ss:mmm' AS
[Standard and Format],
CONVERT(VARCHAR(50), Getdate(), 13) AS [OutputFormat]
UNION ALL
SELECT '14' AS [StyleCode],
' 24 hour time with milliseconds -hh:mm:ss:mmm(24h)' AS
[Standard and Format],
CONVERT(VARCHAR(50), Getdate(), 14) AS [OutputFormat]
UNION ALL
SELECT '20' AS [StyleCode],
'ODBC canonical -yyyy-mm-dd hh:mm:ss(24h)' AS [Standard and Format],
CONVERT(VARCHAR(50), Getdate(), 20) AS [OutputFormat]
UNION ALL
SELECT '21' AS [StyleCode],
'ODBC canonical (with milliseconds) -yyyy-mm-dd hh:mm:ss.mmm' AS
[Standard and Format],
CONVERT(VARCHAR(50), Getdate(), 21) AS [OutputFormat]
UNION ALL
SELECT '22' AS [StyleCode],
'mm/dd/yy hh:mm:ss AM (or PM)' AS [Standard and Format],
CONVERT(VARCHAR(50), Getdate(), 22) AS [OutputFormat]
UNION ALL
SELECT '23' AS [StyleCode],
'ISO 8601 - yyyy-mm-dd' AS [Standard and Format],
CONVERT(VARCHAR(50), Getdate(), 23) AS [OutputFormat]
UNION ALL
SELECT '100' AS [StyleCode],
'mon dd yyyy hh:mmAM' AS [Standard and Format],
CONVERT(VARCHAR(50), Getdate(), 100) AS [OutputFormat]
UNION ALL
SELECT '101' AS [StyleCode],
'USA -mm/dd/yyyy' AS [Standard and Format],
CONVERT(VARCHAR(50), Getdate(), 101) AS [OutputFormat]
UNION ALL
SELECT '102' AS [StyleCode],
'ANSI -yyyy.mm.dd' AS [Standard and Format],
CONVERT(VARCHAR(50), Getdate(), 102) AS [OutputFormat]
UNION ALL
SELECT '103' AS [StyleCode],
'British/French -dd/mm/yyyy' AS [Standard and Format],
CONVERT(VARCHAR(50), Getdate(), 103) AS [OutputFormat]
UNION ALL
SELECT '104' AS [StyleCode],
'German - dd.mm.yyyy' AS [Standard and Format],
CONVERT(VARCHAR(50), Getdate(), 104) AS [OutputFormat]
UNION ALL
SELECT '105' AS [StyleCode],
'Italian -dd-mm-yyyy' AS [Standard and Format],
CONVERT(VARCHAR(50), Getdate(), 105) AS [OutputFormat]
UNION ALL
SELECT '106' AS [StyleCode],
'Shortened month name -dd mon yyyy' AS [Standard and Format],
CONVERT(VARCHAR(50), Getdate(), 106) AS [OutputFormat]
UNION ALL
SELECT '107' AS [StyleCode],
'Shortened month name -mon dd, yyyy' AS [Standard and Format],
CONVERT(VARCHAR(50), Getdate(), 107) AS [OutputFormat]
UNION ALL
SELECT '108' AS [StyleCode],
'24 hour time -hh:mm:ss' AS [Standard and Format],
CONVERT(VARCHAR(50), Getdate(), 108) AS [OutputFormat]
UNION ALL
SELECT '109' AS
[StyleCode],
'Default + milliseconds -mon dd yyyy hh:mm:ss:mmmAM (or PM) ' AS
[Standard and Format],
CONVERT(VARCHAR(50), Getdate(), 109) AS [OutputFormat]
UNION ALL
SELECT '110' AS [StyleCode],
'USA -mm-dd-yyyy' AS [Standard and Format],
CONVERT(VARCHAR(50), Getdate(), 110) AS [OutputFormat]
UNION ALL
SELECT '111' AS [StyleCode],
'JAPAN -yyyy/mm/dd' AS [Standard and Format],
CONVERT(VARCHAR(50), Getdate(), 111) AS [OutputFormat]
UNION ALL
SELECT '112' AS [StyleCode],
'ISO -yyyymmdd' AS [Standard and Format],
CONVERT(VARCHAR(50), Getdate(), 112) AS [OutputFormat]
UNION ALL
SELECT '113' AS [StyleCode],
'Europe default + milliseconds -dd mon yyyy hh:mm:ss:mmm' AS
[Standard and Format],
CONVERT(VARCHAR(50), Getdate(), 113) AS [OutputFormat]
UNION ALL
SELECT '114' AS [StyleCode],
' 24 hour time with milliseconds -hh:mm:ss:mmm(24h)' AS
[Standard and Format],
CONVERT(VARCHAR(50), Getdate(), 114) AS [OutputFormat]
UNION ALL
SELECT '120' AS [StyleCode],
'ODBC canonical- yyyy-mm-dd hh:mm:ss(24h)' AS [Standard and Format],
CONVERT(VARCHAR(50), Getdate(), 120) AS [OutputFormat]
UNION ALL
SELECT '121' AS [StyleCode],
'ODBC canonical (with milliseconds) -yyyy-mm-dd hh:mm:ss.mmm' AS
[Standard and Format],
CONVERT(VARCHAR(50), Getdate(), 121) AS [OutputFormat]
UNION ALL
SELECT '126' AS [StyleCode],
'ISO8601 -yyyy-mm-ddThh:mm:ss.mmm' AS [Standard and Format],
CONVERT(VARCHAR(50), Getdate(), 126) AS [OutputFormat]
UNION ALL
SELECT '127' AS [StyleCode],
'ISO8601 with time zone Z-yyyy-mm-ddThh:mm:ss.mmmZ' AS
[Standard and Format],
CONVERT(VARCHAR(100), Getdate(), 127) AS [OutputFormat]
UNION ALL
SELECT '131' AS [StyleCode],
'Arabic Hijri date - Islamic calendar' AS [Standard and Format],
CONVERT(VARCHAR(100), Getdate(), 131) AS [OutputFormat]

Dans la capture d'écran ci-dessous, vous pouvez voir le code de style, leurs normes, formats et dates de sortie.

Convertir des dates à l'aide de la fonction FORMAT()

Dans la fonction CONVERT() ci-dessus, nous devons spécifier des codes de style pour une sortie de format spécifique. Habituellement, nous ne voulons pas avoir à nous souvenir de ces codes; par conséquent, Microsoft a introduit la fonction FORMAT() dans SQL Server 2012.

La syntaxe est indiquée ci-dessous.

FORMAT (valeur, format [, culture])

Valeur :Il nécessite une valeur dans le format pris en charge. Vous pouvez vous référer à la documentation Microsoft pour une liste détaillée.

Formater :Dans le format, nous pouvons spécifier les codes de format ou le modèle pour dissimuler les données de date d'entrée. Le script ci-dessous montre les codes de format, le modèle et le format de sortie.

DECLARE @InputDate DATETIME = '2020-12-08 15:58:17.643'
SELECT 'd' AS [FormatCode],
'Short Date Pattern' AS 'Pattern',
Format(@InputDate, 'd') AS 'Output'
UNION ALL
SELECT 'D' AS [FormatCode],
'Long Date Pattern' AS 'Pattern',
Format(@InputDate, 'D') AS 'Output'
UNION ALL
SELECT 'f' AS [FormatCode],
'Full Date/Time pattern (Short Time)' AS 'Pattern',
Format(@InputDate, 'f') AS 'Output'
UNION ALL
SELECT 'F' AS [FormatCode],
'Full Date/Time pattern (Long Time)' AS 'Pattern',
Format(@InputDate, 'F')
UNION ALL
SELECT 'g' AS [FormatCode],
'General Date/Time pattern (Short Time)' AS 'Pattern',
Format(@InputDate, 'g')
UNION ALL
SELECT 'G' AS [FormatCode],
'General Date/Time pattern (Long Time)' AS 'Pattern',
Format(@InputDate, 'G') AS 'Output'
UNION ALL
SELECT 'm' AS [FormatCode],
'Month/Day pattern' AS 'Pattern',
Format(@InputDate, 'm') AS 'Output'
UNION ALL
SELECT 'O' AS [FormatCode],
'Round trip Date/Time pattern' AS 'Pattern',
Format(@InputDate, 'O') AS 'Output'
UNION ALL
SELECT 'R' AS [FormatCode],
'RFC1123 pattern' AS 'Pattern',
Format(@InputDate, 'R') AS 'Output'
UNION ALL
SELECT 's' AS [FormatCode],
'Sortable Date/Time pattern' AS 'Pattern',
Format(@InputDate, 's') AS 'Output'
UNION ALL
SELECT 't' AS [FormatCode],
'Short Time pattern' AS 'Pattern',
Format(@InputDate, 't') AS 'Output'
UNION ALL
SELECT 'T' AS [FormatCode],
'Long Time Pattern' AS 'Pattern',
Format(@InputDate, 'T') AS 'Output'
UNION ALL
SELECT 'u' AS [FormatCode],
'Universal sortable Date/Time pattern' AS 'Pattern',
Format(@InputDate, 'u') AS 'Output'
UNION ALL
SELECT 'U' AS [FormatCode],
'Universal Full Date/Time pattern' AS 'Pattern',
Format(@InputDate, 'U') AS 'Output'
UNION ALL
SELECT 'Y' AS [FormatCode],
'Year Month pattern' AS 'Pattern',
Format(@InputDate, 'Y') AS 'Output'

Culture :C'est un argument facultatif et définit la culture. Si nous ne spécifions aucune culture, SQL Server utilise la langue de la session en cours.

Dans la requête ci-dessous, nous allons convertir un format de date dans une culture spécifiée. Nous devons spécifier le code de culture. Par exemple, le code culturel pour les États-Unis est en-US et hi-IN pour l'Inde.

Les scripts utilisent le d code de format pour les modèles de date courte.

DECLARE @d DATETIME ='2020-12-08 16:36:17.760';
SELECT FORMAT (@d, 'd', 'en-US') AS 'US English',
FORMAT (@d, 'd', 'no') AS 'Norwegian Result',
FORMAT(@d, 'd', 'hi-IN') AS 'India',
FORMAT(@d, 'd', 'ru-RU') AS 'Russian',
FORMAT(@d, 'd', 'gl-ES') AS 'Galician (Spain)',
FORMAT ( @d, 'd', 'en-gb' ) AS 'Great Britain English',
FORMAT (@d, 'd', 'zu') AS 'Zulu',
FORMAT ( @d, 'd', 'de-de' ) AS 'German',
FORMAT ( @d, 'd', 'zh-cn' ) AS 'Simplified Chinese (PRC)';

Vous obtenez le format de date dans une culture spécifiée, comme indiqué ci-dessous.

Si vous voulez que la date sorte dans le modèle date/heure complet (heure longue), spécifiez le code de format F, et cela changera rapidement votre format de date.

Dans le format de date, vous pouvez également spécifier les formats personnalisés et il convertit la chaîne de date d'entrée selon vos besoins.

Pour spécifier les chaînes personnalisées, nous pouvons utiliser les abréviations suivantes.

  • jj :jour du mois (01 au 31)
  • dddd :orthographe du jour
  • MM :Numéro du mois (01 à 12)
  • MMMM :orthographe du mois
  • aa :année à deux chiffres
  • aaaa :année sur quatre chiffres
  • hh :C'est l'heure de 01 à 12
  • HH :Cela donne 24 heures. format heure 00 à 23
  • mm :minutes 00 à 59
  • ss :seconde de 00 à 59
  • tt :AM ou PM

Dans le script ci-dessous, nous avons converti les formats de date d'entrée en plusieurs formats en utilisant les abréviations ou codes ci-dessus.

DECLARE @d DATETIME ='2020-12-08 16:36:17.760';
SELECT
FORMAT (@d,'dd/MM/yyyy ') as [Date Format 1] ,
FORMAT (@d, 'dd/MM/yyyy, hh:mm:ss ') as [Date Format 2] ,
FORMAT(@d,'yyyy-MM-dd HH:mm:ss')as [Date Format 3] ,
FORMAT(@d,'Dd MMM yyyy HH:mm:ss')as [Date Format 4] ,
FORMAT(@d,'MMM d yyyy h:mm:ss')as [Date Format 5] ,
FORMAT (@d, 'dddd, MMMM, yyyy')as [Date Format 6] ,
FORMAT (@d, 'MMM dd yyyy') as [Date Format 7] ,
FORMAT (@d, 'MM.dd.yy') as [Date Format 8] ,
FORMAT (@d, 'MM-dd-yy') as [Date Format 9] ,
FORMAT (@d, 'hh:mm:ss tt')as [Date Format 10] ,
FORMAT (@d, 'd-M-yy')as [Date Format 11] ,
FORMAT(@d,'MMMM dd,yyyy')as [Date Format 12]

Utilisation de AT TIME ZONE dans SQL Server 2016 ou version ultérieure

Différents pays suivent différents fuseaux horaires. Habituellement, ces fuseaux horaires suivent le décalage par rapport au temps universel coordonné (UTC). Voici quelques exemples de fuseaux horaires :

  • Heure avancée du centre de l'Australie :UTC +10:30
  • Heure standard de l'Inde :UTC +5:30
  • Heure avancée des Rocheuses :UTC-6
  • Heure de Singapour :UTC+8
  • Heure avancée du Centre :UTC-5

Vous pouvez vous référer à cet article pour une liste détaillée des fuseaux horaires.

De nombreux pays suivent l'heure d'été et l'horloge est réglée sur 1 heure (ou 30-45 minutes) selon les fuseaux horaires. Par exemple, l'heure avancée du Centre a suivi le calendrier ci-dessous :

  • L'heure standard a commencé :le 1er novembre 2020 à 02h00, heure locale. Les horloges ont été reculées d'une heure.
  • L'heure standard se termine le 14 mars 2021 à 02h00, heure locale. Les horloges avanceront d'une heure.

SQL Server n'est pas conscient de ces fuseaux horaires et de l'heure d'été. Habituellement, une organisation suit les zones UTC car cela ne nécessite aucun changement.

Comment pouvons-nous convertir les fuseaux horaires dans SQL Server ?

Vous pouvez utiliser AT TIME ZONE à partir de SQL Server 2016 et convertir les fuseaux horaires. Dans la requête ci-dessous, il affiche les dates pour l'heure normale du Centre, l'heure normale de l'Inde et l'heure normale des Samoa.

Declare @DateinUTC datetime2='2020-11-01 02:00:00'
select
@DateinUTC AT TIME ZONE 'UTC' AT TIME ZONE 'Central Standard Time' as 'Central Standard Time' ,
@DateinUTC AT TIME ZONE 'UTC' AT TIME ZONE 'India Standard Time' as 'India Standard Time',
@DateinUTC AT TIME ZONE 'UTC' AT TIME ZONE 'Samoa Standard Time' as 'Samoa Standard Time',
@DateinUTC AT TIME ZONE 'UTC' AT TIME ZONE 'Dateline Standard Time' as 'Dateline Standard Time'

Pour connaître les fuseaux horaires pris en charge, vous pouvez interroger sys.time_zone_info  et il renvoie le fuseau horaire et le décalage.

Vous pouvez ensuite filtrer les fuseaux horaires qui respectent actuellement l'heure d'été.

Select * from sys.time_zone_info where is_currently_dst=1

Considérons maintenant l'heure d'été pour l'heure de l'Est.

  • L'heure d'été a commencé le dimanche 8 mars 2020 à 2 h.
  • L'heure d'été a pris fin :le dimanche 1er novembre 2020 à 2 h.

Convertissez votre zone UTC en heure normale de l'Est et vous pourrez constater l'impact de l'heure d'été.

DECLARE
@PreDST datetime = '2020-03-08 06:59:00',
@PostDST datetime = '2020-03-08 07:00:00';
SELECT
@PreDST AT TIME ZONE 'UTC' AT TIME ZONE 'Eastern Standard Time' AS [EST time before DST],
@PostDST AT TIME ZONE 'UTC' AT TIME ZONE 'Eastern Standard Time' AS [EST time before DST];

Points utiles pour l'utilisation des formats de date SQL CONVERT

Évaluez les exigences de votre application et choisissez la date de type de données appropriée, SmallDateTime, DateTime, DateTime2 et DateTimeOffset.

Vous pouvez convertir le format de date à l'aide des fonctions SQL CONVERT date et FORMAT; cependant, il est conseillé d'utiliser le format qui correspond le mieux à vos charges de travail. Cela vous évitera d'avoir à utiliser la conversion de date explicite.

Vous pouvez tenir compte de l'heure d'été dans SQL Server à l'aide de la fonction AT TIME ZONE à partir de SQL