Meilleure approche pour supprimer la partie temps de datetime dans SQL Server

Quelle méthode offre les meilleures performances lors de la suppression de la partie temps d'un champ datetime dans SQL Server?

a) select DATEADD(dd, DATEDIFF(dd, 0, getdate()), 0)

ou

b) select cast(convert(char(11), getdate(), 113) as datetime)

La deuxième méthode envoie quelques octets de plus dans les deux cas, mais cela pourrait ne pas être aussi important que la vitesse de la conversion.

Les deux semblent également être très rapides, mais il peut y avoir une différence de vitesse lors du traitement de centaines de milliers ou plus de lignes?

En outre, est-il possible qu'il existe des méthodes encore meilleures pour se débarrasser de la partie temporelle d'un datetime dans SQL?

Strictement, la méthode aest la moins gourmande en ressources:

a) select DATEADD(dd, DATEDIFF(dd, 0, getdate()), 0)

Éprouvé moins gourmand en ressources processeur pour la même durée totale d'un million de lignes par quelqu'un avec beaucoup trop de temps à disposition: le moyen le plus efficace dans SQL Server pour obtenir la date à partir de la date + heure?

J'ai vu un test similaire ailleurs avec des résultats similaires aussi.

Je préfère le DATEADD / DATEDIFF car:

• varchar est sujet à des problèmes de langue / format de date
  Exemple: Pourquoi mon expression CASE est-elle non déterministe?
• le flotteur repose sur le stockage interne
• il s'étend pour s'entraîner le premier jour du mois, demain, etc. en changeant la base "0"

Edit, oct 2011

Pour SQL Server 2008+, vous pouvez CAST vers dateie CAST(getdate() AS date). Ou utilisez simplement le datetype de données afin de ne pas le supprimer.

Edit, janv 2012

Un exemple concret de la flexibilité de ceci: besoin de calculer par heure ou date arrondie dans le serveur SQL

Edit, mai 2012

N'utilisez pas cela dans les clauses WHERE et similaires sans réfléchir: l'ajout d'une fonction ou CAST à une colonne invalide l'utilisation de l'index. Voir le numéro 2 ici: http://www.simple-talk.com/sql/t-sql-programming/ten-common-sql-programming-mistakes/

Maintenant, cela a un exemple de versions ultérieures de l'optimiseur SQL Server gérant correctement CAST à ce jour, mais généralement ce sera une mauvaise idée ...

Edit, sept. 2018, pour datetime2

DECLARE @datetime2value datetime2 = '02180912 11:45' --this is deliberately within datetime2, year 0218
DECLARE @datetime2epoch datetime2 = '19000101'

select DATEADD(dd, DATEDIFF(dd, @datetime2epoch, @datetime2value), @datetime2epoch)

Dans SQL Server 2008, vous pouvez utiliser:

CONVERT(DATE, getdate(), 101)

Bien sûr, c'est un vieux fil mais pour le compléter.

À partir de SQL 2008, vous pouvez utiliser le type de données DATE pour effectuer simplement:

SELECT CONVERT(DATE,GETDATE())

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

... n'est pas une bonne solution, selon les commentaires ci-dessous.

Je supprimerais cette réponse, mais je la laisserai ici comme contre-exemple car je pense que l'explication des commentateurs de pourquoi ce n'est pas une bonne idée est toujours utile.

Dans SQL Server 2008, il existe un type de données DATE (également un type de données TIME).

CAST(GetDate() as DATE)

ou

declare @Dt as DATE = GetDate()

Voici encore une autre réponse, à partir d'une autre question en double:

SELECT CAST(CAST(getutcdate() - 0.50000004 AS int) AS datetime) 

Cette méthode de nombre magique fonctionne légèrement plus rapidement que la méthode DATEADD. (Il ressemble à ~ 10%)

Le temps CPU sur plusieurs tours d'un million d'enregistrements:

DATEADD   MAGIC FLOAT
500       453
453       360
375       375
406       360

Mais notez que ces chiffres ne sont peut-être pas pertinents car ils sont déjà TRÈS rapides. À moins d'avoir des jeux d'enregistrements de 100 000 ou plus, je ne pouvais même pas obtenir le temps CPU pour lire au-dessus de zéro.

Compte tenu du fait que DateAdd est destiné à cet effet et est plus robuste, je dirais utiliser DateAdd.

SELECT CAST(CAST(GETDATE() AS DATE) AS DATETIME)

J'aime vraiment:

[date] = CONVERT(VARCHAR(10), GETDATE(), 120)

Le 120code de format contraindra la date dans la norme ISO 8601:

'YYYY-MM-DD' or '2017-01-09'

Super facile à utiliser dans dplyr ( R) et pandas ( Python)!

IL FAUT SE MÉFIER!

Les méthodes a) et b) n'ont PAS toujours la même sortie!

select DATEADD(dd, DATEDIFF(dd, 0, '2013-12-31 23:59:59.999'), 0)

Production: 2014-01-01 00:00:00.000

select cast(convert(char(11), '2013-12-31 23:59:59.999', 113) as datetime)

Production: 2013-12-31 00:00:00.000

(Testé sur MS SQL Server 2005 et 2008 R2)

EDIT: Selon le commentaire d'Adam, cela ne peut pas se produire si vous lisez la valeur de date dans le tableau, mais cela peut se produire si vous fournissez votre valeur de date comme un littéral (exemple: comme paramètre d'une procédure stockée appelée via ADO.NET).

Temps de bande sur les insertions / mises à jour en premier lieu. En ce qui concerne la conversion à la volée, rien ne peut battre une fonction définie par l'utilisateur en termes de maintenabilité:

select date_only(dd)

L'implémentation de date_onlypeut être tout ce que vous aimez - maintenant, elle est abstraite et le code d'appel est beaucoup plus propre.

Voir cette question:
Comment puis-je tronquer un datetime dans SQL Server?

Quoi que vous fassiez, n'utilisez pas la méthode chaîne . C'est à peu près la pire façon de le faire.

Déjà répondu, mais mal jeté cela aussi ... cela semble aussi bien préformer mais cela fonctionne en jetant la décimale (qui stocke le temps) du flotteur et en ne retournant qu'une partie entière (qui est la date)

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

la deuxième fois que j'ai trouvé cette solution ... j'ai saisi ce code

CAST(round(cast(getdate()as real),0,1) AS datetime)

Cette méthode n'utilise pas de fonction de chaîne. Dateest fondamentalement un vrai type de données avec des chiffres avant que les décimales ne soient une fraction de jour.

je suppose que ce sera plus rapide que beaucoup.

Pour moi, le code ci-dessous est toujours gagnant:

SELECT CONVERT(DATETIME, FLOOR(CONVERT(FLOAT,GETDATE())));

sélectionnez CONVERTIR (char (10), GetDate (), 126)

je pense que vous voulez dire cast(floor(cast(getdate()as float))as datetime)

réel n'est que de 32 bits et pourrait perdre des informations

C'est le plus rapide cast(cast(getdate()+x-0.5 as int)as datetime)

... mais seulement 10% plus rapide(about 0.49 microseconds CPU vs. 0.58)

Cela a été recommandé et prend le même temps dans mon test tout à l'heure: DATEADD(dd, DATEDIFF(dd, 0, getdate()), 0)

Dans SQL 2008, la fonction SQL CLR est environ 5 fois plus rapide que l'utilisation d'une fonction SQL, soit 1,35 microsecondes contre 6,5 microsections, ce qui indique une surcharge d'appel de fonction beaucoup plus faible pour une fonction SQL CLR par rapport à un simple UDF SQL.

Dans SQL 2005, la fonction SQL CLR est 16 fois plus rapide, selon mes tests, par rapport à cette fonction lente:

create function dateonly (  @dt datetime )
returns datetime
as
begin
return cast(floor(cast(@dt as float))as int)
end

Et alors select cast(cast my_datetime_field as date) as datetime)? Cela se traduit par la même date, avec l'heure définie à 00:00, mais évite toute conversion en texte et évite également tout arrondi numérique explicite.

Je pense que si vous vous en tenez strictement à TSQLcela, c'est le moyen le plus rapide de tronquer le temps:

 select convert(datetime,convert(int,convert(float,[Modified])))

J'ai trouvé que cette méthode de troncature était environ 5% plus rapide que la DateAddméthode. Et cela peut être facilement modifié pour arrondir au jour le plus proche comme ceci:

select convert(datetime,ROUND(convert(float,[Modified]),0))

Ici, j'ai créé une fonction pour supprimer certaines parties d'un datetime pour SQL Server. Usage:

• Le premier paramètre est le datetime à supprimer.
• Le deuxième paramètre est un caractère:
  • s: arrondit aux secondes; supprime les millisecondes
  • m: tours à minutes; supprime les secondes et les millisecondes
  • h: arrondis à heures; supprime les minutes, les secondes et les millisecondes.
  • d: arrondis à jours; supprime les heures, les minutes, les secondes et les millisecondes.
• Renvoie le nouveau datetime

create function dbo.uf_RoundDateTime(@dt as datetime, @part as char) returns datetime as begin if CHARINDEX( @part, 'smhd',0) = 0 return @dt; return cast( Case @part when 's' then convert(varchar(19), @dt, 126) when 'm' then convert(varchar(17), @dt, 126) + '00' when 'h' then convert(varchar(14), @dt, 126) + '00:00' when 'd' then convert(varchar(14), @dt, 112) end as datetime ) end

Juste au cas où quelqu'un chercherait ici une version Sybase car plusieurs des versions ci-dessus ne fonctionnaient pas

CAST(CONVERT(DATE,GETDATE(),103) AS DATETIME)

• Testé dans I SQL v11 exécuté sur Adaptive Server 15.7

Si possible, pour des choses spéciales comme celle-ci, j'aime utiliser les fonctions CLR.

Dans ce cas:

[Microsoft.SqlServer.Server.SqlFunction]
    public static SqlDateTime DateOnly(SqlDateTime input)
    {
        if (!input.IsNull)
        {
            SqlDateTime dt = new SqlDateTime(input.Value.Year, input.Value.Month, input.Value.Day, 0, 0, 0);

            return dt;
        }
        else
            return SqlDateTime.Null;
    }

Personnellement, j'utilise presque toujours des fonctions définies par l'utilisateur dans le cas de SQL Server 2005 (ou version inférieure), cependant, il convient de noter qu'il existe des inconvénients spécifiques à l'utilisation des FDU, en particulier si vous les appliquez aux clauses WHERE (voir ci-dessous et commentaires sur cette réponse pour plus de détails). Si vous utilisez SQL Server 2008 (ou supérieur) - voir ci-dessous.

En fait, pour la plupart des bases de données que je crée, j'ajoute ces UDF juste au début car je sais qu'il y a 99% de chances que j'en ai besoin tôt ou tard.

J'en crée un pour "date seulement" et "heure seulement" (bien que celui "date seulement" soit de loin le plus utilisé des deux).

Voici quelques liens vers une variété d'UDF liés à la date:

Fonctions essentielles de date, d'heure et de date et heure de SQL Server Fonction
Get Date Only

Ce dernier lien montre pas moins de 3 façons différentes d'obtenir la date seulement une partie d'un champ datetime et mentionne certains avantages et inconvénients de chaque approche.

Si vous utilisez un UDF, il convient de noter que vous devez essayer d'éviter d'utiliser l'UDF dans le cadre d'une clause WHERE dans une requête, car cela entravera considérablement les performances de la requête. La raison principale en est que l'utilisation d'une FDU dans une clause WHERE rend cette clause non-sargable , ce qui signifie que SQL Server ne peut plus utiliser d'index avec cette clause afin d'améliorer la vitesse d'exécution des requêtes. En référence à ma propre utilisation des UDF, j'utiliserai fréquemment la colonne de date "brute" dans la clause WHERE, mais j'appliquerai l'UDF à la colonne SELECTed. De cette façon, l'UDF est uniquement appliqué à l'ensemble de résultats filtré et non à chaque ligne du tableau dans le cadre du filtre.

Bien sûr, la meilleure approche absolue pour cela consiste à utiliser SQL Server 2008 (ou supérieur) et à séparer vos dates et heures , car le moteur de base de données SQL Server fournit alors nativement les composants individuels de date et d'heure, et peut les interroger efficacement indépendamment sans avoir besoin d'un UDF ou d'un autre mécanisme pour extraire la partie date ou heure d'un type composite datetime.

J'utiliserais:

CAST
(
CAST(YEAR(DATEFIELD) as varchar(4)) + '/' CAST(MM(DATEFIELD) as varchar(2)) + '/' CAST(DD(DATEFIELD) as varchar(2)) as datetime
) 

Ainsi, vous créez efficacement un nouveau champ à partir du champ de date que vous avez déjà.