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

SELECT GETDATE()

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

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

Comment puis-je l'obtenir?

À partir de SQL Server 2008maintenant, vous devez 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()))

Donne moi

2008-09-22 00:00:00.000

Avantages:

• Aucune varchar<-> datetimeconversion requise
• Pas besoin de penser locale

Comme suggéré par Michael

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

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()))

Production:

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

SQLServer 2008 dispose désormais d'un type de données «date» qui contient uniquement une date sans composant d'heure. Toute personne utilisant SQLServer 2008 et au-delà peut 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 sont meilleurs que CONVERT 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 pour exécuter toutes les pièces. Si les deux requêtes sont exécutées sur une table avec des millions de lignes, le temps CPU utilisant DateDiff peut être proche du 1/3 du temps Convert CPU!

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 pour certains, elle est plus lente. Il n'est pas nécessaire de revenir à datetime (cela est implicitement fait par le serveur). Il n'y a pas non plus de réel besoin dans la méthode DateDiff pour DateAdd par la suite, car le résultat entier sera également reconverti implicitement en datetime.

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]))

SELECT DATEADD (dd, 0, DATEDIFF (dd, 0, MyDate)) FROM DatesTable

  |--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 l'a suggéré @digi a des performances plus proches de DateDiff, mais n'est pas recommandée car la conversion du type de données datetime en float et back ne donne 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!

Soyez prudent lorsque vous testez vos résultats. La sélection de plusieurs lignes pour 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 pour toutes les lignes est effectué par le serveur mais qu'aucun ensemble de lignes n'est envoyé au client.

Il semble y avoir de la confusion pour certaines personnes sur le 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 distincts n'a aucun effet sur la mise en cache. Ainsi, vous pouvez soit expirer le cache manuellement, soit simplement exécuter les requêtes d'avant en arrière plusieurs fois. Toute optimisation pour la requête # 2 affecterait également toutes les requêtes ultérieures, alors jetez l'exécution # 1 si vous le souhaitez.

Voici un script de test complet et des résultats de performances qui prouvent que DateDiff est nettement plus rapide que la conversion en varchar.

Essaye ça:

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

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

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

Pour retour au format date

CAST (OrderDate AS date)

Le code ci-dessus fonctionnera dans SQL Server 2010

Il reviendra comme 12/12/2013

Pour SQL Server 2012, utilisez le code ci-dessous

CONVERT(VARCHAR(10), OrderDate , 111)

Vous pouvez utiliser la CONVERTfonction pour renvoyer uniquement 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:

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

Si vous avez besoin du résultat en tant que 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 avez besoin d'un résultat au format date et heure, vous devez utiliser l'une des requêtes ci-dessous

1. SELECT CONVERT(DATETIME, CONVERT(VARCHAR(10), GETDATE(), 111)) AS OnlyDate 

   2014-03-26 00: 00: 00.000

2. SELECT CONVERT(DATETIME, CONVERT(VARCHAR(10), GETDATE(), 112)) AS OnlyDate 

   2014-03-26 00: 00: 00.000

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

   2014-03-26 00: 00: 00.000

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 () - il suffit de couper la partie temporelle.

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

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

Utilisez la Format()fonction.

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 serait difficile pour vous de vous souvenir des nombres pour le type de format ou les fonctions par rapport au format de date spécifique. C'est pourquoi dans les prochaines versions de SQL Server, il y a une meilleure option.

FORMAT ( value, format [, culture ] )

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

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

1. "d" - Motif de date court.

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" - Motif 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 sur:

1. Chaînes de format de date et d'heure standard
2. Chaînes de format de date et d'heure personnalisées

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

Si je peux accéder à ma boîte à savon pendant 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 des `` astuces '' stupides à frais généraux élevés jusqu'à SQL Server 2008, lorsque les types de données de partie de date réels sont introduit. Effectuer de telles conversions dans le niveau de données est un énorme gaspillage de frais généraux sur votre SGBD, mais plus important encore, la seconde où vous faites quelque chose comme ça, vous avez essentiellement créé des données orphelines en mémoire que je suppose que vous retournerez ensuite à un programme. Vous ne pouvez pas le replacer dans une autre colonne 3NF + ou le comparer à quelque chose tapé sans revenir en arrière, donc tout ce que vous avez fait est d'introduire des points de défaillance et de supprimer la référence relationnelle.

Vous devez TOUJOURS continuer et renvoyer votre type de données dateTime au programme appelant et dans le niveau PRESENTATION, faire les ajustements nécessaires. Dès que vous allez convertir des choses 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, encore une fois, sauf si vous effectuez une sorte de réversion manuelle, qui expose à nouveau vos données à une erreur humaine / code / gremlin lorsqu'il n'y a pas besoin.

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

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

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

Edit: Les deux premières méthodes sont essentiellement les mêmes, et exécutez 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 c'est utile.

 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, donnez-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

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

D'accord, bien que je sois 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 supérieur, vous pouvez utiliser une FORMAT()fonction comme celle-ci -

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

Même en utilisant l'ancien MSSQL Server 7.0, le code ici (gracieuseté de ce lien ) m'a permis d'obtenir le format de date que je recherchais à 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 produit 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

Date:

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

Temps:

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

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 comme:

2008-09-22 00:00:00.000

Ou faites simplement ceci:

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

Résultat:

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

pourquoi n'utilisez-vous pas DATE_FORMAT (your_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éorganisant la '%d-%m-%Y'partie

Je sais que c'est vieux, mais je ne vois pas où quelqu'un 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)

Ce serait bien si Microsoft pouvait également prendre en charge la variable CURRENT_DATE standard ANSI.

Je suis favorable à ce qui n'a pas été mentionné:

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

Il ne se soucie pas non plus du local ou fait une double conversion - bien que chaque «datepart» fasse probablement des calculs. Cela peut donc être un peu plus lent que la méthode datiff, mais pour moi, c'est beaucoup plus clair. Surtout quand je veux regrouper uniquement l'année et le mois (régler le jour sur 1).

À partir de SQL SERVER 2012, vous pouvez faire ceci:

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)

Dans ce cas, date uniquement, vous allez exécuter cette requête:

SELECT CONVERT (VARCHAR (10), getdate (), 111);

Vous pouvez utiliser les éléments suivants pour la partie date et le formatage de la date:

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

DATEADD => La DATEPART()fonction est utilisée pour renvoyer une seule partie d'une date / heure, comme l'année, le mois, le jour, l'heure, la minute, etc.

DATEPART => Renvoie un entier qui représente la partie date spécifiée de la date spécifiée.

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