Comment renvoyer uniquement la date à partir d'un type de données SQL Server DateTime

https://stackoverflow.com/questions/113045

02-07-2019
|

Question

SELECT GETDATE()

Retourne: 2008-09-22 15:24:13.790

Je veux cette partie de date sans la partie heure: 2008-09-22 00:00:00.000

Comment puis-je l'obtenir?

La solution

À partir de SQL Server 2008 et supérieur, vous devriez CONVERT à ce jour:

SELECT CONVERT(date, getdate())

Sur les anciennes versions, vous pouvez effectuer les opérations suivantes:

SELECT DATEADD(dd, 0, DATEDIFF(dd, 0, @your_date))

par exemple

SELECT DATEADD(dd, 0, DATEDIFF(dd, 0, GETDATE()))

me donne

2008-09-22 00:00:00.000

Avantages:

Non varchar < - > datetime conversions requises
Inutile de penser à locale

Comme suggéré par Michael

Utilisez cette variante: SELECT DATEADD(dd, 0, DATEDIFF(dd, 0, getdate()))

select getdate()

SELECT DATEADD(hh, DATEDIFF(hh, 0, getdate()), 0)
SELECT DATEADD(hh, 0, DATEDIFF(hh, 0, getdate()))

SELECT DATEADD(dd, DATEDIFF(dd, 0, getdate()), 0)
SELECT DATEADD(dd, 0, DATEDIFF(dd, 0, getdate()))

SELECT DATEADD(mm, DATEDIFF(mm, 0, getdate()), 0)
SELECT DATEADD(mm, 0, DATEDIFF(mm, 0, getdate()))

SELECT DATEADD(yy, DATEDIFF(yy, 0, getdate()), 0)
SELECT DATEADD(yy, 0, DATEDIFF(yy, 0, getdate()))

Sortie:

2019-04-19 08:09:35.557

2019-04-19 08:00:00.000
4763-02-17 00:00:00.000

2019-04-19 00:00:00.000
2019-04-19 00:00:00.000

2019-04-01 00:00:00.000
1903-12-03 00:00:00.000

2019-01-01 00:00:00.000
1900-04-30 00:00:00.000

Autres conseils

SQLServer 2008 a maintenant un type de données 'date' qui contient uniquement une date sans composant horaire. Toute personne utilisant SQLServer 2008 et les versions ultérieures peuvent effectuer les opérations suivantes:

SELECT CONVERT(date, GETDATE())

Si vous utilisez SQL 2008 et supérieur:

select cast(getdate() as date)

DATEADD et DATEDIFF valent mieux que CONVERTIR en varchar. Les deux requêtes ont le même plan d'exécution, mais les plans d'exécution concernent principalement les stratégies d'accès aux données et ne révèlent pas toujours les coûts implicites impliqués dans le temps CPU nécessaire à la réalisation de tous les éléments. Si les deux requêtes sont exécutées sur une table contenant des millions de lignes, le temps processeur à l'aide de DateDiff peut être voisin de 1/3 du temps de conversion du processeur!

Pour voir les plans d'exécution des requêtes:

set showplan_text on
GO

DATEADD et DATEDIFF exécuteront un CONVERT_IMPLICIT.

Bien que la solution CONVERT soit plus simple et plus facile à lire, elle est plus lente . Il n'est pas nécessaire de reconvertir datetime (cela est implicitement fait par le serveur). De plus, la méthode DateDiff n’a pas réellement besoin de DateAdd par la suite, car le résultat de l’entier sera également reconverti implicitement en date / heure.

SELECT CONVERT (varchar, MyDate, 101) FROM DatesTable

  |--Compute Scalar(DEFINE:([Expr1004]=CONVERT(varchar(30),[TEST].[dbo].[DatesTable].[MyDate],101)))
       |--Table Scan(OBJECT:([TEST].[dbo].[DatesTable]))

SÉLECTIONNER DATEADD (jj, 0, DATEDIFF (jj, 0, MyDate)) FROM DateTable

  |--Compute Scalar(DEFINE:([Expr1004]=dateadd(day,(0),CONVERT_IMPLICIT(datetime,datediff(day,'1900-01-01 00:00:00.000',CONVERT_IMPLICIT(datetime,[TEST].[dbo].[DatesTable].[MyDate],0)),0))))
       |--Table Scan(OBJECT:([TEST].[dbo].[DatesTable]))

L'utilisation de FLOOR () comme suggéré par @digi a des performances plus proches de DateDiff, mais il n'est pas recommandé, car le transfert du type de données datetime à float et retour ne génère pas toujours la valeur d'origine.

N'oubliez pas les gars: ne croyez personne. Regardez les statistiques de performances et testez-les vous-même!

Faites attention lorsque vous testez vos résultats. La sélection de nombreuses lignes sur le client masquera la différence de performances car il faut plus de temps pour envoyer les lignes sur le réseau que pour effectuer les calculs. Assurez-vous donc que le travail de toutes les lignes est effectué par le serveur, mais qu'aucun ensemble de lignes n'est envoyé au client.

Il semble y avoir une confusion chez certaines personnes quant au moment où l’optimisation du cache affecte les requêtes. L'exécution de deux requêtes dans le même lot ou dans des lots séparés n'a aucun effet sur la mise en cache. Ainsi, vous pouvez soit expirer manuellement le cache, soit simplement exécuter les requêtes à plusieurs reprises. Toute optimisation de la requête n ° 2 affectera également les requêtes suivantes. Par conséquent, annulez l'exécution n ° 1 si vous le souhaitez.

Voici script de test complet et résultats de performance prouvant que DateDiff est nettement plus rapide que la conversion en varchar.

Essayez ceci:

SELECT CONVERT(VARCHAR(10),GETDATE(),111)

La déclaration ci-dessus convertit votre format actuel en YYYY/MM/DD, veuillez vous reporter à ce lien pour choisir votre format préférable.

SELECT CONVERT(datetime, CONVERT(varchar, GETDATE(), 101))

Vous pouvez utiliser la fonction CONVERT pour ne renvoyer que la date. Voir le (s) lien (s) ci-dessous:

Manipulation de la date et de l'heure dans SQL Server 2000

CAST et CONVERT

La syntaxe d'utilisation de la fonction convert est la suivante:

CONVERT ( data_type [ ( length ) ] , expression [ , style ] )

Pour le retour au format de date

CAST (date du bon de commande)

Le code ci-dessus fonctionnera dans SQL Server 2010

Cela reviendra comme le 12/12/2013

Pour SQL Server 2012, utilisez le code ci-dessous

CONVERT(VARCHAR(10), OrderDate , 111)

SELECT CONVERT(VARCHAR,DATEADD(DAY,-1,GETDATE()),103) --21/09/2011

SELECT CONVERT(VARCHAR,DATEADD(DAY,-1,GETDATE()),101) --09/21/2011

SELECT CONVERT(VARCHAR,DATEADD(DAY,-1,GETDATE()),111) --2011/09/21

SELECT CONVERT(VARCHAR,DATEADD(DAY,-1,GETDATE()),107) --Sep 21, 2011

Utilisation de FLOOR () - coupez simplement le temps.

SELECT CAST(FLOOR(CAST(GETDATE() AS FLOAT)) AS DATETIME)

Si vous utilisez des versions de SQL Server 2012 ou supérieures ,

Utilisez la fonction Format() .

Il existe déjà plusieurs réponses et types de formatage pour SQL Server. Mais la plupart des méthodes sont quelque peu ambiguës et il vous serait difficile de vous souvenir des numéros de type de format ou de fonctions par rapport au format de date spécifique. C’est pourquoi, dans les prochaines versions de SQL Server, il existe une meilleure option.

FORMAT ( value, format [, culture ] )

L'option Culture est très utile car vous pouvez spécifier la date en fonction de vos téléspectateurs.

Vous devez vous rappeler d (pour les petits motifs) et D (pour les longs motifs).

1. & "; d &"; - Modèle de date courte.

2009-06-15T13:45:30 -> 6/15/2009 (en-US)
2009-06-15T13:45:30 -> 15/06/2009 (fr-FR)
2009-06-15T13:45:30 -> 2009/06/15 (ja-JP)

2. " D " - Modèle de date longue.

2009-06-15T13:45:30 -> Monday, June 15, 2009 (en-US)
2009-06-15T13:45:30 -> 15 июня 2009 г. (ru-RU)
2009-06-15T13:45:30 -> Montag, 15. Juni 2009 (de-DE)

Plus d'exemples dans la requête.

DECLARE @d DATETIME = '10/01/2011';
SELECT FORMAT ( @d, 'd', 'en-US' ) AS 'US English Result'
      ,FORMAT ( @d, 'd', 'en-gb' ) AS 'Great Britain English Result'
      ,FORMAT ( @d, 'd', 'de-de' ) AS 'German Result'
      ,FORMAT ( @d, 'd', 'zh-cn' ) AS 'Simplified Chinese (PRC) Result'; 

SELECT FORMAT ( @d, 'D', 'en-US' ) AS 'US English Result'
      ,FORMAT ( @d, 'D', 'en-gb' ) AS 'Great Britain English Result'
      ,FORMAT ( @d, 'D', 'de-de' ) AS 'German Result'
      ,FORMAT ( @d, 'D', 'zh-cn' ) AS 'Chinese (Simplified PRC) Result';

US English Result Great Britain English Result  German Result Simplified Chinese (PRC) Result
----------------  ----------------------------- ------------- -------------------------------------
10/1/2011         01/10/2011                    01.10.2011    2011/10/1

US English Result            Great Britain English Result  German Result                    Chinese (Simplified PRC) Result
---------------------------- ----------------------------- -----------------------------  ---------------------------------------
Saturday, October 01, 2011   01 October 2011               Samstag, 1. Oktober 2011        2011年10月1日

Si vous voulez plus de formats, vous pouvez aller à:

SI vous voulez utiliser CONVERT et obtenir le même résultat que dans la question d'origine, c'est-à-dire aaaa-mm-jj, utilisez CONVERT(varchar(10),[SourceDate as dateTime],121) le même code que les réponses précédentes, mais le code à convertir en aaaa- mm-jj avec des tirets est 121.

Si je peux accéder à ma tribune une seconde, ce type de formatage n'appartient pas au niveau de données , et c'est pourquoi cela n'a pas été possible sans "astuces" ridicules jusqu'à SQL Server 2008, lorsque les types de données datepart sont introduits. Réaliser de telles conversions dans la couche de données représente un gaspillage énorme de votre SGBD, mais plus important encore, dès que vous faites quelque chose comme cela, vous avez essentiellement créé des données orphelines en mémoire qui, je suppose, seront ensuite restaurées dans un programme. Vous ne pouvez pas le réintégrer dans une autre colonne 3NF + ni le comparer à un élément tapé sans revenir en arrière. Vous n'avez donc qu'à introduire les points d'échec et à supprimer les références relationnelles.

Vous devez TOUJOURS aller de l'avant et renvoyer votre type de données dateTime au programme appelant et dans le niveau PRÉSENTATION, effectuez les ajustements nécessaires. Dès que vous effectuez la conversion. avant de les renvoyer à l'appelant, vous supprimez tout espoir d'intégrité référentielle de l'application. Cela empêcherait une opération UPDATE ou DELETE, à moins que vous ne fassiez une sorte de réversion manuelle, ce qui exposerait à nouveau vos données à une erreur humain / code / gremlin quand cela ne serait pas nécessaire.

SELECT DATEADD(DD, DATEDIFF(DD, 0, GETDATE()), 0)

SELECT DATEADD(DAY, 0, DATEDIFF(DAY,0, GETDATE()))

SELECT CONVERT(DATETIME, CONVERT(VARCHAR(10), GETDATE(), 101))

Éditer: les deux premières méthodes sont essentiellement les mêmes et exécutent la méthode de conversion en varchar.

Pour obtenir le résultat indiqué, j'utilise la commande suivante.

SELECT CONVERT(DATETIME,CONVERT(DATE,GETDATE()))

Je holpe il est utile.

Si vous devez obtenir le type de données varchar, vous devez passer par

SELECT CONVERT(DATE, GETDATE()) --2014-03-26
SELECT CONVERT(VARCHAR(10), GETDATE(), 111) --2014/03/26

qui est déjà mentionné ci-dessus

Si vous souhaitez obtenir un format de date et d'heure, vous devez utiliser l'une des requêtes ci-dessous

1) SELECT CONVERT(DATETIME,CONVERT(VARCHAR(10), GETDATE(), 111)) comme OnlyDate --2014-03-26 00: 00: 00.000

2) SELECT CONVERT(DATETIME,CONVERT(VARCHAR(10), GETDATE(), 112)) comme OnlyDate --2014-03-26 00: 00: 00.000

 DECLARE  @OnlyDate DATETIME
   SET @OnlyDate = DATEDIFF(DD, 0, GETDATE())
   SELECT @OnlyDate AS OnlyDate

- 2014-03-26 00: 00: 00.000

 Convert(nvarchar(10), getdate(), 101) --->  5/12/14

 Convert(nvarchar(12), getdate(), 101) --->  5/12/2014

Si vous affectez les résultats à une colonne ou à une variable, indiquez-lui le type DATE et la conversion est implicite.

DECLARE @Date DATE = GETDATE()   

SELECT @Date   --> 2017-05-03

Je pense que cela fonctionnerait dans votre cas:

CONVERT(VARCHAR(10),Person.DateOfBirth,111) AS BirthDate
//here date is obtained as 1990/09/25

Bien, même si je suis un peu en retard :), voici une autre solution.

SELECT CAST(FLOOR(CAST(GETDATE() AS FLOAT)) as DATETIME)

Résultat

2008-09-22 00:00:00.000

Et si vous utilisez SQL Server 2012 et versions ultérieures, vous pouvez utiliser FORMAT() une fonction comme celle-ci -

SELECT FORMAT(GETDATE(), 'yyyy-MM-dd')

Même en utilisant l'ancien serveur MSSQL 7.0, le code est ici (avec la permission de ceci link ) m'a permis d'obtenir le format de date que je cherchais à l'époque:

PRINT '1) Date/time in format MON DD YYYY HH:MI AM (OR PM): ' + CONVERT(CHAR(19),GETDATE())  
PRINT '2) Date/time in format MM-DD-YY: ' + CONVERT(CHAR(8),GETDATE(),10)  
PRINT '3) Date/time in format MM-DD-YYYY: ' + CONVERT(CHAR(10),GETDATE(),110) 
PRINT '4) Date/time in format DD MON YYYY: ' + CONVERT(CHAR(11),GETDATE(),106)
PRINT '5) Date/time in format DD MON YY: ' + CONVERT(CHAR(9),GETDATE(),6) 
PRINT '6) Date/time in format DD MON YYYY HH:MM:SS:MMM(24H): ' + CONVERT(CHAR(24),GETDATE(),113)

Il a généré cette sortie:

1) Date/time in format MON DD YYYY HH:MI AM (OR PM): Feb 27 2015  1:14PM
2) Date/time in format MM-DD-YY: 02-27-15
3) Date/time in format MM-DD-YYYY: 02-27-2015
4) Date/time in format DD MON YYYY: 27 Feb 2015
5) Date/time in format DD MON YY: 27 Feb 15
6) Date/time in format DD MON YYYY HH:MM:SS:MMM(24H): 27 Feb 2015 13:14:46:630

DECLARE @yourdate DATETIME = '11/1/2014 12:25pm'    
SELECT CONVERT(DATE, @yourdate)

Date:

SELECT CONVERT(date, GETDATE())
SELECT CAST(GETDATE() as date)

Heure:

SELECT CONVERT(time , GETDATE() , 114)
SELECT CAST(GETDATE() as time)

Je suis favorable aux éléments suivants qui n'ont pas été mentionnés:

DATEFROMPARTS(DATEPART(yyyy, @mydatetime), DATEPART(mm, @mydatetime), DATEPART(dd, @mydatetime))

Cela ne s’inquiète pas non plus de la conversion locale ou de la conversion double - bien que chaque "datepart" fasse probablement des calculs. Cela peut donc être un peu plus lent que la méthode de datiff, mais pour moi, c'est beaucoup plus clair. Surtout quand je veux grouper uniquement par année et par mois (régler le jour à 1).

À partir de SQL SERVER 2012, vous pouvez procéder comme suit:

SELECT FORMAT(GETDATE(), 'yyyy-MM-dd 00:00:00.000')

Sur SQL Server 2000

CAST(
(
    STR( YEAR( GETDATE() ) ) + '/' +
    STR( MONTH( GETDATE() ) ) + '/' +
    STR( DAY( GETDATE() ) )
)
AS DATETIME)

Vous pouvez simplement le faire de cette façon:

SELECT CONVERT(date, getdate())
SELECT DATEADD(dd, 0, DATEDIFF(dd, 0, @your_date))
SELECT DATEADD(dd, 0, DATEDIFF(dd, 0, GETDATE()))

Sorties en tant que:

2008-09-22 00:00:00.000

Ou faites simplement comme ceci:

SELECT CONVERT (DATE, GETDATE()) 'Date Part Only'

Résultat:

Date Part Only
--------------
2013-07-14

pourquoi n'utilisez-vous pas DATE_FORMAT (votre_datetiem_column, '% d-% m-% Y')?

EX: select DATE_FORMAT( some_datetime_column, '%d-%m-%Y' ) from table_name

vous pouvez changer la séquence de m, d et année en réarrangeant '%d-%m-%Y' une partie

Je sais que c'est vieux, mais je ne vois pas où quiconque l'a déclaré de cette façon. D'après ce que je peux dire, c'est la norme ANSI.

SELECT CAST(CURRENT_TIMESTAMP AS DATE)

Il serait bon que Microsoft puisse également prendre en charge la variable ANUR standard CURRENT_DATE.

Cela manquait dans toutes les réponses. Peut-être pas le plus efficace, mais très facile à écrire et à comprendre, pas de style, pas de fonctions de date complexes.

SELECT CONVERT(DATETIME,CONVERT(DATE,((GETDATE()))))

Vous pouvez utiliser ce qui suit pour la date et le formatage de la date:

DATENAME = > Renvoie une chaîne de caractères représentant la date spécifiée de la date spécifiée

DATEADD = > La fonction DATEPART() permet de renvoyer une partie d'une date / heure, telle que l'année, le mois, le jour, l'heure, les minutes, etc.

DATEPART = > Renvoie un entier représentant la date spécifiée de la date spécifiée.

CONVERT() = > La fonction <=> est une fonction générale qui convertit une expression d'un type de données en un autre. le La fonction <=> peut être utilisée pour afficher les données de date / heure dans différents formats.

Licencié sous: CC-BY-SA avec attribution

Non affilié à StackOverflow