Como retornar apenas a data de um tipo de dados DateTime do SQL Server

SELECT GETDATE()

Devoluções: 2008-09-22 15:24:13.790

Quero essa parte da data sem a parte da hora: 2008-09-22 00:00:00.000

Como eu consigo isso?

Em geral SQL Server 2008, você deve CONVERTnamorar:

SELECT CONVERT(date, getdate())

Nas 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

Prós:

• Não são necessárias conversões varchar<->datetime
• Não há necessidade de pensar locale

Como sugerido por Michael

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

Resultado:

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

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

SELECT CONVERT(date, GETDATE())

Se estiver usando o SQL 2008 e acima:

select cast(getdate() as date)

DATEADD e DATEDIFF são melhores que CONVERTING para varchar. Ambas as consultas têm o mesmo plano de execução, mas os planos de execução são principalmente sobre estratégias de acesso a dados e nem sempre revelam custos implícitos envolvidos no tempo de CPU necessário para executar todas as peças. Se as duas consultas forem executadas em uma tabela com milhões de linhas, o tempo da CPU usando DateDiff poderá ser próximo a 1/3 do tempo da CPU de conversão!

Para ver os planos de execução de consultas:

set showplan_text on
GO 

DATEADD e DATEDIFF executarão um CONVERT_IMPLICIT.

Embora a solução CONVERT seja mais simples e fácil de ler para alguns, é mais lenta. Não é necessário retroceder para a data e hora (isso é implicitamente feito pelo servidor). Também não há necessidade real no método DateDiff para o DateAdd posteriormente, pois o resultado inteiro também será implicitamente convertido novamente em 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]))

O uso de FLOOR () como @digi sugerido tem desempenho mais próximo de DateDiff, mas não é recomendado, pois converter o tipo de dados de data e hora para flutuar e voltar nem sempre gera o valor original.

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

Tenha cuidado ao testar seus resultados. A seleção de muitas linhas para o cliente ocultará a diferença de desempenho, pois leva mais tempo para enviar as linhas pela rede do que para executar os cálculos. Portanto, verifique se o trabalho para todas as linhas é feito pelo servidor, mas não há um conjunto de linhas enviado ao cliente.

Parece haver confusão para algumas pessoas sobre quando a otimização do cache afeta as consultas. A execução de duas consultas no mesmo lote ou em lotes separados não afeta o cache. Portanto, você pode expirar o cache manualmente ou simplesmente executar as consultas várias vezes. Qualquer otimização para a consulta nº 2 também afetaria as consultas subseqüentes; portanto, descarte a execução nº 1, se desejar.

Aqui estão os resultados completos do script de teste e desempenho que provam que o DateDiff é substancialmente mais rápido do que converter para varchar.

Tente o seguinte:

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

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

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

Para retorno em formato de data

CAST (data da data do pedido AS)

O código acima funcionará no sql server 2010

Voltará como 12/12/2013

Para o SQL Server 2012, use o código abaixo

CONVERT(VARCHAR(10), OrderDate , 111)

Você pode usar a CONVERTfunção para retornar apenas a data. Veja os links abaixo:

Manipulação de data e hora no SQL Server 2000

CAST e CONVERT

A sintaxe para usar a função convert é:

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

Se você precisar do resultado como um varchar, deve passar por

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

que já foi mencionado acima.

Se você precisar resultar no formato de data e hora, use qualquer uma das consultas abaixo

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

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 () - basta cortar parte do tempo.

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

Se você estiver usando o SQL Server 2012 ou versões posteriores ,

Use a Format()função

Já existem várias respostas e tipos de formatação para o SQL server. Mas a maioria dos métodos é um tanto ambígua e seria difícil lembrar os números para o tipo ou funções de formato em relação ao formato específico da data. É por isso que nas próximas versões do SQL Server há uma opção melhor.

FORMAT ( value, format [, culture ] )

A opção Cultura é muito útil, pois você pode especificar a data conforme seus espectadores.

Você deve se lembrar de d (para padrões pequenos) e D (para padrões longos).

1. "d" - padrão de data curta.

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

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, pode ir para:

1. Sequências de formato de data e hora padrão
2. Seqüências de caracteres de formato de data e hora personalizadas

Se você deseja usar CONVERT e obter a mesma saída da pergunta original, ou seja, aaaa-mm-dd, use o CONVERT(varchar(10),[SourceDate as dateTime],121)mesmo código das respostas anteriores, mas o código para converter para aaaa-mm-dd com traços é 121

Se eu puder entrar na minha caixa de sabão por um segundo, esse tipo de formatação não pertence à camada de dados , e é por isso que não era possível sem os 'truques' bobos de sobrecarga até o SQL Server 2008, quando os tipos de dados reais da parte de data são introduzido. Fazer essas conversões na camada de dados é um enorme desperdício de sobrecarga no DBMS, mas o mais importante é que, no momento em que você faz algo parecido com isso, você basicamente cria dados órfãos na memória que eu suponho que você retornará a um programa. Você não pode colocá-lo novamente em outra coluna 3NF + ou compará-lo com qualquer coisa digitada sem reverter, portanto tudo o que você fez foi introduzir pontos de falha e remover a referência relacional.

SEMPRE siga em frente e retorne seu tipo de dados dateTime ao programa de chamada e, na camada APRESENTAÇÃO, faça os ajustes necessários. Assim que você converter as coisas antes de devolvê-las ao chamador, estará removendo toda a esperança de integridade referencial do aplicativo. Isso impediria uma operação UPDATE ou DELETE, novamente, a menos que você faça algum tipo de reversão manual, que novamente expõe seus dados a erro humano / código / 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))

Edit: Os dois primeiros métodos são essencialmente os mesmos, e executamos o método convert to varchar.

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

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

Eu acho que é útil.

 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, forneça o tipo DATE e a conversão estará implícita.

DECLARE @Date DATE = GETDATE()   

SELECT @Date   --> 2017-05-03

Eu acho que isso funcionaria no seu caso:

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

DECLARE @yourdate DATETIME = '11/1/2014 12:25pm'    
SELECT CONVERT(DATE, @yourdate)

Ok, embora eu esteja um pouco atrasado :), Aqui está 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 o SQL Server 2012 e superior, poderá usar uma FORMAT()função como esta -

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

Mesmo usando o antigo MSSQL Server 7.0, o código aqui (cortesia deste link ) me permitiu obter qualquer formato de data que eu estava procurando na época:

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)

Produziu 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

Encontro:

SELECT CONVERT (data, GETDATE ())
SELECIONAR CAST (GETDATE () como data)

Tempo:

SELECT CONVERT (hora, GETDATE (), 114)
SELECIONAR CAST (GETDATE () como hora)

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 faça assim:

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

Resultado:

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

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

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

você pode alterar a sequência de m, de ano reorganizando a '%d-%m-%Y'parte

Eu sei que isso é antigo, mas não vejo onde alguém o declarou dessa maneira. Pelo que sei, esse é o padrão ANSI.

SELECT CAST(CURRENT_TIMESTAMP AS DATE)

Seria bom se a Microsoft também pudesse suportar a variável CURRENT_DATE do padrão ANSI.

Sou a favor do seguinte, que não foi mencionado:

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

Também não se importa com o local ou faz uma conversão dupla - embora cada 'datepart' provavelmente faça matemática. Portanto, pode ser um pouco mais lento que o método datado, mas para mim é muito mais claro. Especialmente quando eu quero agrupar apenas o ano e o mês (defina o dia como 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)

Nesse caso, somente data, você executaremos esta consulta:

SELECT CONVERT (VARCHAR (10), getdate (), 111);

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

DATENAME => Retorna uma cadeia de caracteres que representa o período especificado da data especificada

DATEADD => A DATEPART()função é usada para retornar uma única parte de uma data / hora, como ano, mês, dia, hora, minuto, etc.

DATEPART => Retorna um número inteiro que representa o período especificado da data especificada.

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