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?
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?
Respostas:
Em geral SQL Server 2008
, você deve CONVERT
namorar:
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:
varchar
<->datetime
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
datetime
tipo de dados não pode ter tempo . Eu acho que você está confundindo armazenamento de dados com apresentação do usuário. Se tudo o que você deseja é uma maneira de mostrar a um usuário uma string que não tem parte do tempo (não zera, apenas espaços em branco), você simplesmente deseja Convert(varchar(30), @Date, 101)
ou algo semelhante. Consulte Manuais Online do SQL Server • Conversão e conversão para obter mais informações.
CAST(... AS DATE)
ou CONVERT(DATE, ...)
, que já foi mencionado com frequência nesta página.
SELECT DATEADD(dd, DATEDIFF(dd, 0, @your_date), 0)
porque então dd
pode ser trocada por qualquer outra datepart
palavra-chave para truncar a sua datetime
em um nível arbitrário.
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)
DateTime2
vez disso e funciona bem. sqlfiddle.com/#!6/9eecb7/2833
2015-10-01
devido a DateTime
limitações. Tente sem elenco Date
, ele 2015-10-01
também rende ! declare @date1 datetime = '2015-09-30 23:59:59.999';select @date1
=>2015-10-01
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.
mm/dd/yyyy
formato.
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 CONVERT
função para retornar apenas a data. Veja os links abaixo:
Manipulação de data e hora no SQL Server 2000
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
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
Usando FLOOR () - basta cortar parte do tempo.
SELECT CAST(FLOOR(CAST(GETDATE() AS FLOAT)) AS DATETIME)
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).
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)
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:
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.
WHERE col >= @Date AND col < DATEADD(DAY, 1, @Date);
- não há absolutamente nenhuma razão para retirar o tempo da coluna.
@Date
tem uma parte do tempo zero. Caso isso não seja verdade, você ainda precisará saber como truncar os horários do servidor. Concordo com esta resposta que a formatação deve ser deixada para a camada de apresentação, mas não concordo com a implicação de que deixar isso para o front end significa que você não precisa conhecer uma maneira rápida de truncar.
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.
select dateadd(dd, datediff(dd, 0, getdate()), 0)
, porque os dd
s podem então ser trocados por qualquer uma das datepart
palavras-chave para cortar a data em qualquer segmento que você escolher. (Note também que dd
é apenas uma abreviação para day
.)
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
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.
select {fn current_date()} as today
funciona para mim.
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).
Nesse caso, somente data, você executaremos esta consulta:
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.