Como retornar somente a data a partir de um tipo de dados SQL Server DateTime

https://stackoverflow.com/questions/113045

02-07-2019
|

Pergunta

SELECT GETDATE()

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

Eu quero que parte da data sem a parte tempo: 2008-09-22 00:00:00.000

Como posso obter isso?

Solução

Em SQL Server 2008 e superior, você deve CONVERT até à data:

SELECT CONVERT(date, getdate())

Em versões mais antigas, você pode fazer o seguinte:

SELECT DATEADD(dd, 0, DATEDIFF(dd, 0, @your_date))

Por exemplo

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

me dá

2008-09-22 00:00:00.000

Pros:

No varchar <-> conversões datetime necessário
Não há necessidade de pensar sobre locale

Como sugerido por Michael

Use esta variante: SELECT DATEADD(dd, 0, DATEDIFF(dd, 0, getdate()))

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

Output:

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

Outras dicas

SQLServer 2008 agora tem um tipo de dados 'date' que contém apenas uma data sem nenhum componente de tempo. Qualquer pessoa que use SQLServer 2008 e além pode fazer o seguinte:

SELECT CONVERT(date, GETDATE())

Se estiver usando SQL 2008 e acima:

select cast(getdate() as date)

DATEADD e DATEDIFF são melhores do que a conversão para varchar. Ambas as consultas têm o mesmo plano de execução, mas os planos de execução são primarly sobre dados estratégias de acesso e nem sempre revelam custos implícitos envolvidos no tempo de CPU necessário para realizar todas as peças. Se ambas as consultas são executadas contra uma tabela com milhões de linhas, o tempo de CPU usando DateDiff pode estar perto de 1 / 3rd do tempo Convert CPU!

Para ver planos de execução para consultas:

set showplan_text on
GO

Ambos DATEADD e DATEDIFF irá executar um CONVERT_IMPLICIT.

Embora a solução CONVERT é mais simples e mais fácil de ler para alguns, é mais lento. Não há necessidade de elenco de volta para datetime (isto é feito implicitamente pelo servidor). Também não há necessidade real no método DateDiff para DateAdd depois que o resultado inteiro também estará de volta implicitamente convertido para data e hora.

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

SELECCIONAR DATEADD (dd, 0, DATEDIFF (dd, 0, MyDate)) DE 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]))

Usando FLOOR () como @digi sugeriu tem um desempenho mais perto de DateDiff, mas não é recomendado como lançando o tipo de dados de data e hora para flutuar e volta nem sempre produzir o valor original.

Lembre-se de caras: Não acredite em ninguém. Olhada nas estatísticas de desempenho e teste você mesmo!

Tenha cuidado quando você está testando seus resultados. Seleção de muitas linhas para o cliente irá esconder os becauses diferença de desempenho leva mais tempo para enviar as linhas através da rede do que para realizar os cálculos. Então certifique-se que o trabalho para todas as linhas é feito pelo servidor, mas não há nenhum conjunto de linhas enviados para o cliente.

Parece haver confusão para algumas pessoas sobre quando a otimização de cache afeta consultas. Correndo duas consultas no mesmo lote ou em lotes separados, não tem efeito sobre o cache. Então você pode expirar o cache manualmente ou simplesmente executar as consultas e para trás várias vezes. Qualquer otimização para consulta # 2 também afetaria quaisquer consultas subsequentes, então jogue fora a execução # 1 se você gosta.

Aqui é script de teste completo e os resultados de desempenho que provar DateDiff é substancialmente mais rápido do que a conversão para varchar.

Tente isto:

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

A declaração acima converte o formato atual para YYYY/MM/DD, consulte este link para escolher o seu formato preferível.

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

Você pode usar a função CONVERT para retornar apenas a data. Veja o link (s) abaixo:

Data e manipulação do tempo no SQL Server 2000

CAST e CONVERT

A sintaxe para utilizar a função de conversão é:

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

Para o retorno no formato de data

CAST (data OrderDate AS)

O código acima irá funcionar no sql server 2010

Ele irá retornar como 12/12/2013

Para o SQL Server 2012 Use o código abaixo

CONVERT(VARCHAR(10), OrderDate , 111)

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

Usando FLOOR () -. Apenas parte do tempo cut

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

Se você estiver usando SQL Server 2012 ou acima de versões ,

Use Format() função.

Já existem várias respostas e formatação tipos de servidor SQL. Mas a maioria dos métodos são um tanto ambígua e que seria difícil para você se lembrar os números para o tipo de formato ou funções com respeito ao formato de data específica. É por isso que nas próximas versões do servidor SQL não há melhor opção.

FORMAT ( value, format [, culture ] )

opção Cultura é muito útil, como você pode especificar data como por seus espectadores.

Você tem que lembrar d (para padrões pequenos) e D (para os padrões de comprimento).

1 "d" -.. Padrão de data abreviada

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" -.. Longa data padrão

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)

Mais exemplos na consulta.

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日

Se você quiser mais formatos, você pode ir para:

Data e formato padrão Tempo Cordas

Data personalizado e formato da hora Cordas

Se você quiser usar converter e obter o mesmo resultado como na pergunta original colocada, isto é, aaaa-mm-dd, em seguida, usar mesmo código CONVERT(varchar(10),[SourceDate as dateTime],121) como as respostas casal anteriores, mas o código para converter a aaaa-mm- dd com traços é 121.

Se eu conseguir no meu palanque por um segundo, este tipo de formatação não pertence a camada de dados , e é por isso que não era possível sem tolas alto sobrecarga 'truques' até que o SQL Server 2008 quando tipos de dados datepart real são introduzidos. Fazendo tais conversões na camada de dados é um enorme desperdício de sobrecarga em seu DBMS, mas o mais importante, o segundo que você fazer algo como isso, você tem basicamente criado dados in-memory órfãos que eu suponho que você irá, em seguida, voltar para um programa. Você não pode colocá-lo de volta para outra coluna 3NF + ou compará-lo com qualquer coisa digitada sem reverter, então tudo que você fez é introduzido pontos de falha e removido referência relacional.

Você deve sempre ir em frente e retornar o tipo de dados dateTime ao programa de chamada e na camada de apresentação, fazer os ajustes são necessários. Assim que você vai converter coisas antes de devolvê-los para o chamador, você está removendo toda a esperança de integridade referencial da aplicação. Isso impediria um UPDATE ou operação DELETE, novamente, a menos que você faça algum tipo de reversão manual, que novamente está expondo seus dados para humano / code / erro gremlin quando não há necessidade.

SELECT DATEADD(DD, DATEDIFF(DD, 0, GETDATE()), 0) SELECT DATEADD(DAY, 0, DATEDIFF(DAY,0, GETDATE())) SELECT CONVERT(DATETIME, CONVERT(VARCHAR(10), GETDATE(), 101))

Editar: Os dois primeiros métodos são essencialmente os mesmos, e se realizar a converso ao método VARCHAR
.

Para obter o resultado indicado, eu uso o seguinte comando.

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

Eu holpe é útil.

Se você precisa resultar em tipo de dados varchar você deve passar por

SELECT CONVERT(DATE, GETDATE()) --2014-03-26 SELECT CONVERT(VARCHAR(10), GETDATE(), 111) --2014/03/26

que já é mencionado acima

Se você precisa resultar em formato de data e hora que você deve passar por qualquer um dos abaixo consulta
1) SELECT CONVERT(DATETIME,CONVERT(VARCHAR(10), GETDATE(), 111)) como OnlyDate --2014-03-26 00: 00: 00.000

2) SELECT CONVERT(DATETIME,CONVERT(VARCHAR(10), GETDATE(), 112)) como 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

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

Se você estiver atribuindo os resultados a uma coluna ou variável, dar-lhe o tipo de data, ea conversão está implícito.

DECLARE @Date DATE = GETDATE() SELECT @Date --> 2017-05-03

Eu acho que isso iria funcionar no seu caso:

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

Ok, Embora eu sou pouco tarde :), aqui é a outra solução.

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

Resultado

2008-09-22 00:00:00.000

E se você estiver usando SQL Server 2012 e superior, em seguida, você pode usar a função FORMAT() como este -

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

Mesmo usando a antiga MSSQL Server 7.0, o código aqui (cortesia de este link ) me permitiu conseguir o formato da data que eu estava procurando no momento:

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)

É produzida esta saída:

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)

Data:

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

Tempo:

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

Eu sou a favor da seguinte que não foi mencionado:

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

Ele também não se preocupa com local ou fazer uma dupla converso - embora cada 'datepart' provavelmente faz matemática. Por isso pode ser um pouco mais lento do que o método datediff, mas para mim é muito mais clara. Especialmente quando eu quero grupo, apenas o ano e mês (definir o dia-a-1).

A partir do SQL Server 2012, você pode fazer isso:

SELECT FORMAT(GETDATE(), 'yyyy-MM-dd 00:00:00.000')

No SQL Server 2000

CAST( ( STR( YEAR( GETDATE() ) ) + '/' + STR( MONTH( GETDATE() ) ) + '/' + STR( DAY( GETDATE() ) ) ) AS DATETIME)

Simplesmente você pode fazer desta maneira:

SELECT CONVERT(date, getdate()) SELECT DATEADD(dd, 0, DATEDIFF(dd, 0, @your_date)) SELECT DATEADD(dd, 0, DATEDIFF(dd, 0, GETDATE()))

Saídas como:

2008-09-22 00:00:00.000

Ou simplesmente fazer assim:

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

Resultado:

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

Por que você não usar DATE_FORMAT (your_datetiem_column, '% d-% m-% Y')?

EX: select DATE_FORMAT( some_datetime_column, '%d-%m-%Y' ) from table_name

Você pode mudar seqüência de m, d e ano, organizando re-parte '%d-%m-%Y'

Eu sei que isso é velho, mas eu não vejo onde ninguém declarou desta forma. Do que eu posso dizer, isso é padrão ANSI.

SELECT CAST(CURRENT_TIMESTAMP AS DATE)

Seria bom se a Microsoft também poderia apoiar a variável CURRENT_DATE padrão ANSI.

Este estava faltando em todas as respostas, pode não ser o mais eficiente, mas muito fácil de escrever e entender, nenhum estilo necessário, há funções de data complexa.

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

Você pode usar o seguinte para a parte data e formatar a data:

DATENAME => Retorna uma cadeia de caracteres que representa o datepart especificada na data
DATEADD => A função DATEPART() é usada para retornar uma única parte de uma data / hora, como o ano, mês, dia, hora, minuto, etc.

DATEPART => Retorna um inteiro que representa o datepart especificada da data especificada.

CONVERT() => A função CONVERT() é uma função geral que converte uma expressão de um tipo de dados para outro. o função CONVERT() pode ser usado para exibição de data / data hora em diferentes formatos.

Licenciado em: CC-BY-SA com atribuição

Não afiliado a StackOverflow

Como retornar somente a data a partir de um tipo de dados SQL Server DateTime

Se você estiver usando SQL Server 2012 ou acima de versões ,

1 "d" -.. Padrão de data abreviada

2 "D" -.. Longa data padrão