Come restituire solo la data da un datatype DateTime di SQL Server

SELECT GETDATE() 

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

Voglio che la parte di data senza la parte di tempo: 2008-09-22 00:00:00.000

Come posso averlo?

Su SQL Server 2008 e versioni successive, è necessario CONVERT fino alla data:

 SELECT CONVERT(date, getdate()) 

Nelle versioni precedenti, puoi eseguire le seguenti operazioni:

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

per esempio

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

mi da

 2008-09-22 00:00:00.000 

Professionisti:

  • Non sono richieste conversioni datetime <->
  • Non c’è bisogno di pensare alle locale

SQLServer 2008 ora ha un tipo di dati ‘data’ che contiene solo una data senza componente orario. Chiunque usi SQL Server 2008 e versioni successive può eseguire le seguenti operazioni:

 SELECT CONVERT(date, GETDATE()) 

Se si utilizza SQL 2008 e versioni successive:

 select cast(getdate() as date) 

DATEADD e DATEDIFF sono migliori di CONVERTING a varchar. Entrambe le query hanno lo stesso piano di esecuzione, ma i piani di esecuzione sono principalmente relativi alle strategie di accesso ai dati e non rivelano sempre i costi impliciti coinvolti nella CPU utilizzata per eseguire tutti i pezzi. Se entrambe le query vengono eseguite su una tabella con milioni di righe, il tempo della CPU utilizzando DateDiff può essere vicino a 1/3 del tempo CPU convertito!

Per vedere i piani di esecuzione per le query:

 set showplan_text on GO 

Sia DATEADD che DATEDIFF eseguiranno un CONVERT_IMPLICIT.

Sebbene la soluzione CONVERT sia più semplice e facile da leggere per alcuni, è più lenta. Non è necessario eseguire il ritorno a datetime (questo viene implicitamente eseguito dal server). Inoltre, non vi è alcuna necessità reale nel metodo DateDiff per DateAdd in seguito, in quanto il risultato intero verrà anche convertito implicitamente in data / ora.


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

L’uso di FLOOR () come suggerito da @digi ha prestazioni più vicine a DateDiff, ma non è consigliato in quanto il casting del tipo di dati datetime su float e back non produce sempre il valore originale.

Ricorda ragazzi: non credere a nessuno. Guarda le statistiche sul rendimento e provalo tu stesso!

Fai attenzione quando stai testando i risultati. La selezione di molte righe sul client nasconderà la differenza di prestazioni perché impiega più tempo a inviare le righe sulla rete rispetto a quando esegue i calcoli. Quindi assicurati che il lavoro per tutte le righe sia fatto dal server ma non ci sia alcun set di righe inviato al client.

Sembra che ci sia confusione per alcune persone su quando l’ottimizzazione della cache influisce sulle query. L’esecuzione di due query nello stesso batch o in batch separati non ha alcun effetto sulla memorizzazione nella cache. In questo modo è ansible espirare la cache manualmente o semplicemente eseguire le query avanti e indietro più volte. Qualsiasi ottimizzazione per la query n. 2 influirebbe anche su eventuali query successive, quindi se si preferisce eliminare l’esecuzione n.

Ecco lo script completo di test e i risultati delle prestazioni che dimostrano che DateDiff è sostanzialmente più veloce della conversione in varchar.

 SELECT CONVERT(VARCHAR(10),GETDATE(),111) 
 SELECT CONVERT(datetime, CONVERT(varchar, GETDATE(), 101)) 

È ansible utilizzare la funzione CONVERT per restituire solo la data. Vedi il link (s) sotto:

Manipolazione di data e ora in SQL Server 2000

CAST e CONVERT

La syntax per l’utilizzo della funzione di conversione è:

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

Per il ritorno in formato data

CAST (Data ordine AS data)

Il codice sopra funzionerà in sql server 2010

Ritornerà come 12/12/2013

Per SQL Server 2012 utilizzare il codice riportato di seguito

 CONVERT(VARCHAR(10), OrderDate , 111) 

Usando FLOOR () – basta tagliare la parte del tempo.

 SELECT CAST(FLOOR(CAST(GETDATE() AS FLOAT)) AS DATETIME) 
 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 

SE si desidera utilizzare CONVERT e ottenere lo stesso risultato della domanda originale, ovvero, aaaa-mm-gg quindi utilizzare CONVERT(varchar(10),[SourceDate as dateTime],121) stesso codice delle precedenti coppie di risposte , ma il codice da convertire in aaaa-mm-gg con trattini è 121.

Se riesco a salire sul mio soapbox per un secondo, questo tipo di formattazione non appartiene al livello dati , ed è per questo che non è stato ansible senza “trucchi” ad alto livello di overhead fino a SQL Server 2008 quando i tipi di dati datapart effettivi sono introdotto. Effettuare tali conversioni nel livello dati è un enorme spreco di spese generali sul DBMS, ma ancora più importante, nel secondo in cui si fa qualcosa del genere, in pratica si sono creati dati orfani in memoria che presumo che si ritorni a un programma. Non è ansible reinserirlo in un’altra colonna 3NF + o confrontarlo con qualsiasi cosa digitato senza ripristinare, quindi tutto ciò che hai fatto è stato introdotto come punto di errore e riferimento relazionale rimosso.

Dovresti SEMPRE andare avanti e restituire il tipo di dati dateTime al programma chiamante e nel livello PRESENTATION, apportare le modifiche necessarie. Non appena vai a convertire le cose prima di restituirle al chiamante, stai rimuovendo ogni speranza di integrità referenziale dall’applicazione. Ciò impedirebbe nuovamente un’operazione UPDATE o DELETE, a meno che non si esegua una sorta di reversione manuale, che di nuovo espone i propri dati all’errore human / code / gremlin quando non ce n’è bisogno.

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

Modifica: i primi due metodi sono essenzialmente gli stessi, e fuori eseguono il metodo convertito in varchar.

Per ottenere il risultato indicato, utilizzo il seguente comando.

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

I holpe è utile.

Se si utilizza SQL Server 2012 o versioni successive ,

Usa la funzione Format() .

Esistono già più risposte e tipi di formattazione per il server SQL. Ma la maggior parte dei metodi è alquanto ambigua e sarebbe difficile per te ricordare i numeri per il tipo di formato o le funzioni rispetto al formato di data specifico. Ecco perché nelle prossime versioni di SQL Server c’è un’opzione migliore.

 FORMAT ( value, format [, culture ] ) 

L’opzione Cultura è molto utile, dato che puoi specificare la data secondo i tuoi spettatori.

Devi ricordare d (per motivi piccoli) e D (per motivi lunghi).

1. “d” – Schema della data breve.

 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” – Modello a data lunga.

 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) 

Altri esempi nella query.

 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 vuoi più formati, puoi andare su:

  1. Stringhe di formato di data e ora standard
  2. Stringhe di formato di data e ora personalizzate
  Convert(nvarchar(10), getdate(), 101) ---> 5/12/14 Convert(nvarchar(12), getdate(), 101) ---> 5/12/2014 

Se hai bisogno di ottenere un tipo di dati varchar, dovresti farlo

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

che è già menzionato sopra

Se hai bisogno di un risultato nel formato di data e ora, dovresti passare attraverso una delle seguenti domande

1) SELECT CONVERT(DATETIME,CONVERT(VARCHAR(10), GETDATE(), 111)) come OnlyDate –2014-03-26 00: 00: 00.000

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

Se stai assegnando i risultati a una colonna o variabile, dagli il tipo DATE e la conversione è implicita.

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

Penso che funzioni nel tuo caso:

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

Ok, anche se sono un po ‘in ritardo :), Ecco l’altra soluzione.

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

Risultato

 2008-09-22 00:00:00.000 

E se utilizzi SQL Server 2012 e versioni successive, puoi utilizzare la funzione FORMAT() questo modo:

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

Anche usando l’antico MSSQL Server 7.0, il codice qui (per gentile concessione di questo link ) mi ha permesso di ottenere qualsiasi formato di data che stavo cercando in quel 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) 

Ha prodotto questa uscita:

 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) 

Io preferisco il seguente che non è stato menzionato:

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

Inoltre non si preoccupa del locale o fa una doppia conversione – anche se ogni “datapart” probabilmente fa matematica. Quindi potrebbe essere un po ‘più lento del metodo datediff, ma per me è molto più chiaro. Soprattutto quando voglio raggruppare solo l’anno e il mese (imposta il giorno su 1).

Data:

 SELEZIONA CONVERT (data, GETDATE ())
 SELEZIONA CAST (GETDATE () come data)

Tempo:

 SELEZIONA CONVERT (tempo, GETDATE (), 114)
 SELEZIONA CAST (GETDATE () come orario)

A partire da SQL SERVER 2012, puoi farlo:

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

Su SQL Server 2000

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

perché non usi DATE_FORMAT (your_datetiem_column, ‘% d-% m-% Y’)?

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

puoi cambiare la sequenza di m, d e anno riordinando la parte '%d-%m-%Y'

Questo mancava in tutte le risposte, potrebbe non essere il più efficiente, ma molto facile da scrivere e capire, non è necessario stile, nessuna funzione data complessa.

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

È ansible utilizzare il seguente per la parte di data e la formattazione della data:

DATENAME => Restituisce una stringa di caratteri che rappresenta la datapart specificata della data specificata

DATEADD => La funzione DATEPART() viene utilizzata per restituire una singola parte di una data / ora, ad esempio anno, mese, giorno, ora, minuto, ecc.

DATEPART => Restituisce un numero intero che rappresenta la datapart specificata della data specificata.

CONVERT() => La funzione CONVERT() è una funzione generale che converte un’espressione di un tipo di dati in un altro. La funzione CONVERT() può essere utilizzata per visualizzare dati di data / ora in diversi formati.

Data (campo data e ora) e DATE_FORMAT (data e ora, ‘% Y-% m-% d’) entrambi restituiscono solo la data di data e ora

So che è vecchio, ma non vedo dove qualcuno lo abbia affermato in questo modo. Da quello che posso dire, questo è lo standard ANSI.

 SELECT CAST(CURRENT_TIMESTAMP AS DATE) 

Sarebbe bene se Microsoft potesse supportare anche la variabile CURRENT_DATE standard ANSI.