Comment retourner seulement la Date D'un type de données DateTime D'un serveur SQL

SQLServer 2008 a maintenant un type de données "date" qui ne contient qu'une date sans composante temporelle. Toute personne utilisant SQLServer 2008 et au-delà peut faire ce qui suit:

SELECT CONVERT(date, GETDATE())

si vous utilisez SQL 2008 et au-dessus:

select cast(getdate() as date)

DATEADD et DATEDIFF sont meilleurs que la conversion en varchar. Les deux requêtes ont le même plan d'exécution, mais les plans d'exécution sont principalement sur données stratégies d'accès et ne révèlent pas toujours les coûts implicites impliqués dans le temps CPU pris pour effectuer tous les morceaux. Si les deux requêtes sont exécutées contre une table avec des millions de lignes, le temps CPU en utilisant DateDiff peut être proche de 1/3ème du temps CPU converti!

pour voir les plans d'exécution questions:

set showplan_text on
GO 

DATEADD et DATEDIFF exécuteront un CONVERT_IMPIF.

bien que la solution de conversion soit plus simple et plus facile à lire pour certains, elle est plus lent. Il n'y a pas besoin de lancer en arrière vers datetime (ceci est implicitement fait par le serveur). Il n'y a pas non plus de besoin réel dans la méthode DateDiff pour DateAdd par la suite puisque le résultat entier sera aussi implicitement converti à datetime.

sélectionnez CONVERT (varchar, MyDate, 101) à partir de la table de données

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

sélectionnez DATEADD(dd, 0, DATEDIFF (dd, 0, MyDate)) à partir du

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

utilisant FLOOR () comme @digi suggéré a une performance plus proche de DateDiff, mais n'est pas recommandé car la coulée du type de données datetime à float et back ne donne pas toujours l'original valeur.

Rappelez-vous les gars: Ne croyez pas les personnes. Regardez les statistiques de performances, et de le tester vous-même!

soyez prudent quand vous testez vos résultats. La sélection de plusieurs lignes au client masquera la différence de performance 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 fait par le serveur mais qu'il n'y a pas de rowset envoyé au client.

il semble y avoir de la confusion chez certaines personnes au sujet du 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 le cache manuellement ou simplement exécuter les requêtes plusieurs fois. N'importe quelle optimisation pour la requête #2 affecterait aussi n'importe quelles requêtes subséquentes, alors jetez l'exécution #1 si vous voulez.

Voici texte complet du test et résultats des performances qui prouve que DateDiff est beaucoup plus rapide que la conversion à varchar.

essayez ceci:

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 retourner dans le format de 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 fonction CONVERT pour retourner seulement la date. Voir le(S) lien (s) ci-dessous:

la Date et le Temps de Manipulation dans SQL Server 2000

moulage et conversion

la syntaxe pour utiliser la fonction convert est:

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

utilisant FLOOR() - il suffit de couper la pièce de temps.

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

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

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

si je peux obtenir sur ma boîte à savon pour une seconde, ce genre de formatage n'a pas sa place dans le niveau de données , et c'est pourquoi il n'a pas été possible sans stupide high-overhead "trucs" jusqu'à ce que SQL Server 2008 lorsque les types de données réels datepart sont introduits. Faire 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éé en mémoire des données orphelines que je suppose que vous reviendrez alors à un programme. Vous ne pouvez pas le remettre dans une autre colonne 3NF+ ou le comparer à quoi que ce soit tapé sans revenir en arrière, donc tout ce que vous avez fait est introduit des points d'échec et supprimé la référence relationnelle.

vous devez toujours aller de l'avant et retourner votre type de données dateTime au programme appelant et dans le niveau de présentation, faire tous les ajustements nécessaires. dès que vous allez convertir les choses avant de les retourner à l'appelant, vous supprimez tout espoir d'intégrité référentielle de l'application. Cela empêcherait une mise à jour ou supprimer une opération, encore une fois, à moins que vous ne fassiez une sorte de réversion manuelle, qui est exposer vos données à l'erreur humain/code/gremlin quand 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 sur Effectuer la conversion à la méthode 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 utilisez SQL Server 2012 ou les versions supérieures ,

Utiliser Format() de la fonction.

il y a 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 rappeler les nombres pour le type de format ou les fonctions en ce qui concerne le 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 ] )

est très utile, car vous pouvez spécifier la date selon vos spectateurs.

vous devez vous souvenir de d (pour les petits motifs) et D (pour les longs motifs).

1."d" - 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" - motif long date.

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 query.

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 peut aller à:

1. chaînes de Format Date et heure Standard
2. personnaliser le Format de Date et Heure des Chaînes

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

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

si vous avez besoin de résultat dans 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 avez besoin de résultat dans le format de date et d'heure, vous devez passer par 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

si vous assignez les résultats à une colonne ou à une variable, donnez-lui le type de DATE, et la conversion est implicite.

DECLARE @Date DATE = GETDATE()   

SELECT @Date   --> 2017-05-03

je pense que cela marcherait dans votre cas:

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

D'accord, mais je suis un peu en retard :), voici l'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 plus, vous pouvez utiliser la fonction FORMAT() comme ceci -

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

même en utilisant l'ancien serveur MSSQL 7.0, le code ici (courtoisie de ce lien 151940920") m'a permis d'obtenir n'importe quel 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)

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)

je suis en faveur de ce qui suit qui n'a pas été mentionné:

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

il ne se soucie pas non plus de local ou de faire une double conversion -- bien que chaque 'plan de données' fait probablement des maths. Donc, il peut être un peu plus lent que la méthode datediff, mais pour moi, il est beaucoup plus clair. Surtout quand je veux Grouper par seulement l'année et le mois (mettez le jour à 1).

Date:

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

Temps:

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

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

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 l'année en réorganisant '%d-%m-%Y' partie

cela manquait dans toutes les réponses, peut-être pas le plus efficace, mais très facile à écrire et à comprendre, pas de style nécessaire, aucune date complexe fonctions.

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

simplement vous pouvez 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:

2008-09-22 00:00:00.000

ou tout simplement faire comme ceci:

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

résultat:

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

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

DATENAME => renvoie une chaîne de caractères qui représente le diagramme de données spécifié de la date spécifiée

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

DATEPART =>renvoie un entier qui représente le datepart spécifié de la date spécifiée.

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

Date(date et heure de champ) et DATE_FORMAT(date et heure,'%Y-%m-%d') les deux renvoie date à partir de la date et de l'heure