Melhor abordagem para remover parte do horário no datetime no SQL Server

Qual método fornece o melhor desempenho ao remover a parte da hora de um campo de data e hora no SQL Server?

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

ou

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

O segundo método envia mais alguns bytes de qualquer maneira, mas isso pode não ser tão importante quanto a velocidade da conversão.

Ambos também parecem ser muito rápidos, mas pode haver uma diferença de velocidade ao lidar com centenas de milhares ou mais de linhas?

Além disso, é possível que haja métodos ainda melhores para se livrar da parte do tempo de um datetime no SQL?

Estritamente, o método aé o menos intensivo em recursos:

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

Comprovou menos uso de CPU para a mesma duração total de um milhão de linhas por alguém com tempo demais em suas mãos: A maneira mais eficiente no SQL Server para obter data a partir de data e hora?

Eu vi um teste semelhante em outro lugar com resultados semelhantes também.

Prefiro o DATEADD / DATEDIFF porque:

• varchar está sujeito a problemas de idioma / formato de data
  Exemplo: Por que minha expressão CASE não é determinística?
• float depende de armazenamento interno
• estende-se ao primeiro dia do mês, amanhã, etc, alterando a base "0"

Editar, outubro de 2011

Para o SQL Server 2008+, você pode CAST para dateie CAST(getdate() AS date). Ou apenas use o datetipo de dados para não ter tempo de remover.

Editar, janeiro de 2012

Um exemplo prático de como isso é flexível: Precisa calcular por hora ou data arredondadas no sql server

Editar, maio de 2012

Não use isso nas cláusulas WHERE e similares sem pensar: adicionar uma função ou CAST a uma coluna invalida o uso do índice. Veja o número 2 aqui: http://www.simple-talk.com/sql/t-sql-programming/ten-common-sql-programming-mistakes/

Agora, isso tem um exemplo de versões posteriores do otimizador do SQL Server que gerenciam o CAST até a data corretamente, mas geralmente será uma má idéia ...

Editar, set 2018, para 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)

No SQL Server 2008, você pode usar:

CONVERT(DATE, getdate(), 101)

Claro que esse é um tópico antigo, mas para torná-lo completo.

No SQL 2008, você pode usar o tipo de dados DATE para fazer o seguinte:

SELECT CONVERT(DATE,GETDATE())

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

... não é uma boa solução, de acordo com os comentários abaixo.

Eu excluiria esta resposta, mas a deixarei aqui como um contra-exemplo, pois acho que a explicação dos comentaristas sobre por que não é uma boa ideia ainda é útil.

No SQL Server 2008, há um tipo de dados DATE (também um tipo de dados TIME).

CAST(GetDate() as DATE)

ou

declare @Dt as DATE = GetDate()

Aqui está mais uma resposta, de outra pergunta duplicada:

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

Esse método de número mágico executa um pouco mais rápido que o método DATEADD. (Parece ~ 10%)

O tempo de CPU em várias rodadas de um milhão de registros:

DATEADD   MAGIC FLOAT
500       453
453       360
375       375
406       360

Mas observe que esses números são possivelmente irrelevantes porque já são MUITO rápidos. A menos que eu tivesse conjuntos de registros de 100.000 ou mais, eu não conseguia nem obter o Tempo de CPU para ler acima de zero.

Considerando o fato de que o DateAdd se destina a essa finalidade e é mais robusto, eu diria que use o DateAdd.

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

Eu realmente gosto:

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

O 120código de formato coagirá a data ao padrão ISO 8601:

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

Super fácil de usar em dplyr ( R) e pandas ( Python)!

Cuidado!

O método a) eb) nem sempre tem a mesma saída!

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

Resultado: 2014-01-01 00:00:00.000

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

Resultado: 2013-12-31 00:00:00.000

(Testado no MS SQL Server 2005 e 2008 R2)

EDIT: De acordo com o comentário de Adam, isso não pode acontecer se você ler o valor da data da tabela, mas pode acontecer se você fornecer o valor da data como um literal (exemplo: como um parâmetro de um procedimento armazenado chamado via ADO.NET).

Tire o tempo das inserções / atualizações em primeiro lugar. Quanto à conversão on-the-fly, nada pode superar uma função definida pelo usuário em termos de manutenção:

select date_only(dd)

A implementação de date_onlypode ser o que você quiser - agora é abstraída e o código de chamada é muito mais limpo.

Veja esta pergunta:
Como posso truncar uma data e hora no SQL Server?

Faça o que fizer, não use o método string . Essa é a pior maneira de fazer isso.

Já respondi, mas vou jogar isso lá fora também ... isso supostamente também se forma bem, mas funciona jogando fora o decimal (que armazena tempo) do flutuador e retornando apenas uma parte inteira (que é a data)

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

segunda vez que encontrei esta solução ... peguei esse código

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

Este método não usa a função string. Dateé basicamente um tipo de dados real com dígitos antes do decimal e fração do dia.

acho que isso será mais rápido do que muito.

Para mim, o código abaixo é sempre um vencedor:

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

selecione CONVERT (char (10), GetDate (), 126)

Eu acho que você quer dizer cast(floor(cast(getdate()as float))as datetime)

real é de apenas 32 bits e pode perder algumas informações

Isso é mais rápido cast(cast(getdate()+x-0.5 as int)as datetime)

... embora apenas 10% mais rápido(about 0.49 microseconds CPU vs. 0.58)

Isso foi recomendado e leva o mesmo tempo no meu teste agora: DATEADD(dd, DATEDIFF(dd, 0, getdate()), 0)

No SQL 2008, a função SQL CLR é cerca de 5 vezes mais rápida do que o uso de uma função SQL, a 1,35 microssegundos versus 6,5 microsecções, indicando uma sobrecarga de chamada de função muito mais baixa para uma função CLR do SQL em comparação com uma simples UDF do SQL.

No SQL 2005, a função SQL CLR é 16 vezes mais rápida, por meu teste, em comparação com essa função lenta:

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

Que tal select cast(cast my_datetime_field as date) as datetime)? Isso resulta na mesma data, com o horário definido para 00:00, mas evita qualquer conversão em texto e também evita qualquer arredondamento numérico explícito.

Eu acho que se você se mantiver estritamente com TSQLisso, esta é a maneira mais rápida de interromper o tempo:

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

Eu achei esse método de truncamento cerca de 5% mais rápido que o DateAddmétodo. E isso pode ser facilmente modificado para arredondar para o dia mais próximo assim:

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

Aqui, criei uma função para remover algumas partes de um datetime para o SQL Server. Uso:

• O primeiro parâmetro é a data e hora a serem removidas.
• O segundo parâmetro é um caractere:
  • s: arredonda para segundos; remove milissegundos
  • m: arredonda para minutos; remove segundos e milissegundos
  • h: arredonda para horas; remove minutos, segundos e milissegundos.
  • d: arredondamentos para dias; remove horas, minutos, segundos e milissegundos.
• Retorna a nova data e hora

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

Caso alguém esteja procurando aqui uma versão do Sybase, pois várias das versões acima não funcionaram

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

• Testado no I SQL v11 em execução no Adaptive Server 15.7

Se possível, para coisas especiais como essa, eu gosto de usar as funções CLR.

Nesse caso:

[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;
    }

Pessoalmente, quase sempre uso funções definidas pelo usuário para isso se estiver lidando com o SQL Server 2005 (ou versão inferior), no entanto, deve-se notar que existem desvantagens específicas no uso de UDFs, especialmente se você for aplicá-las às cláusulas WHERE (veja abaixo e os comentários sobre esta resposta para obter mais detalhes). Se estiver usando o SQL Server 2008 (ou superior) - veja abaixo.

De fato, para a maioria dos bancos de dados criados, eu adiciono esses UDFs logo no início, pois sei que há uma chance de 99% de precisar deles mais cedo ou mais tarde.

Eu crio um para "somente data" e "somente horário" (embora o "somente data" seja de longe o mais usado dos dois).

Aqui estão alguns links para uma variedade de UDFs relacionadas à data:

Essencial SQL Server Data, hora e de data e hora Funções
Obter Data única função

Esse último link mostra nada menos que três maneiras diferentes de obter a data apenas como parte de um campo de data e hora e menciona alguns prós e contras de cada abordagem.

Se você estiver usando um UDF, deve-se observar que você deve evitar o uso do UDF como parte de uma cláusula WHERE em uma consulta, pois isso prejudicará bastante o desempenho da consulta. A principal razão para isso é que o uso de um UDF em uma cláusula WHERE torna essa cláusula não sargável , o que significa que o SQL Server não pode mais usar um índice com essa cláusula para melhorar a velocidade da execução da consulta. Com referência ao meu próprio uso de UDF, usarei frequentemente a coluna de data "bruta" na cláusula WHERE, mas aplicarei o UDF à coluna SELECTed. Dessa maneira, o UDF é aplicado apenas ao conjunto de resultados filtrado e nem a todas as linhas da tabela como parte do filtro.

Obviamente, a melhor abordagem absoluta para isso é usar o SQL Server 2008 (ou superior) e separar suas datas e horas , pois o mecanismo de banco de dados do SQL Server fornece nativamente os componentes individuais de data e hora e pode consultá-los de maneira eficiente. sem a necessidade de um UDF ou outro mecanismo para extrair a parte da data ou hora de um tipo de data e hora composto.

Eu usaria:

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

Assim, criando efetivamente um novo campo a partir do campo de data que você já possui.