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?
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?
Réponses:
À partir de SQL Server 2008
maintenant, 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:
varchar
<-> datetime
conversion requiselocale
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
datetime
type de données ne peut pas avoir du tout de temps . Je pense que vous confondez le stockage de données avec la présentation des utilisateurs. Si tout ce que vous voulez, c'est un moyen de montrer à un utilisateur une chaîne qui n'a pas de partie de temps (pas de zéros, juste des blancs), alors vous voulez simplement Convert(varchar(30), @Date, 101)
ou quelque chose de similaire. Consultez la documentation en ligne de SQL Server • Cast and Convert pour plus d'informations.
CAST(... AS DATE)
ou CONVERT(DATE, ...)
, qui a été mentionné assez souvent sur cette même page.
SELECT DATEADD(dd, DATEDIFF(dd, 0, @your_date), 0)
car il dd
peut alors être échangé contre tout autre datepart
mot clé pour tronquer votre datetime
à un niveau arbitraire.
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)
DateTime2
place et cela fonctionne bien. sqlfiddle.com/#!6/9eecb7/2833
2015-10-01
due à des DateTime
limitations. Essayez sans aucun casting Date
, ça donne 2015-10-01
aussi! declare @date1 datetime = '2015-09-30 23:59:59.999';select @date1
=>2015-10-01
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é.
mm/dd/yyyy
format.
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 CONVERT
fonction pour renvoyer uniquement la date. Voir le (s) lien (s) ci-dessous:
Manipulation de la date et de l'heure dans SQL Server 2000
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
SELECT CONVERT(DATETIME, CONVERT(VARCHAR(10), GETDATE(), 111)) AS OnlyDate
2014-03-26 00: 00: 00.000
SELECT CONVERT(DATETIME, CONVERT(VARCHAR(10), GETDATE(), 112)) AS 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
Utilisation de FLOOR () - il suffit de couper la partie temporelle.
SELECT CAST(FLOOR(CAST(GETDATE() AS FLOAT)) AS DATETIME)
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).
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)
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:
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.
WHERE col >= @Date AND col < DATEADD(DAY, 1, @Date);
- il n'y a absolument aucune raison de retirer le temps de la colonne.
@Date
a une partie de temps zéro. Dans le cas où ce n'est pas vrai, vous devez toujours savoir comment tronquer les temps côté serveur. Je suis d'accord avec cette réponse que la mise en forme devrait être laissée à la couche de présentation, mais je n'étais pas d'accord avec une implication selon laquelle laisser cela pour le front-end signifie que vous n'avez pas besoin de connaître un moyen rapide de tronquer.
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.
select dateadd(dd, datediff(dd, 0, getdate()), 0)
, parce que les dd
s peuvent alors être permutées pour l' une des les datepart
mots - clés pour couper la date à tout segment que vous choisissez. (Notez également que ce dd
n'est qu'une abréviation pour day
.)
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
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.
select {fn current_date()} as today
travaille pour moi.
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).
Dans ce cas, date uniquement, vous allez exécuter cette requête:
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.