Come restituire solo la data da un tipo di dati DateTime di SQL Server

SELECT GETDATE()

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

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

Come posso ottenerlo?

A partire da SQL Server 2008, dovresti uscire CONVERTcon:

SELECT CONVERT(date, getdate())

Nelle versioni precedenti, è possibile effettuare 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:

• Nessuna varchar<-> datetimeconversione richiesta
• Non c'è bisogno di pensarci locale

Come suggerito da Michael

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

Produzione:

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

SQLServer 2008 ora ha un tipo di dati 'data' che contiene solo una data senza componente temporale. Chiunque utilizzi SQL Server 2008 e oltre 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 meglio di CONVERTING su varchar. Entrambe le query hanno lo stesso piano di esecuzione, ma i piani di esecuzione riguardano principalmente le strategie di accesso ai dati e non rivelano sempre i costi impliciti associati al tempo impiegato dalla CPU per eseguire tutti i pezzi. Se entrambe le query vengono eseguite su una tabella con milioni di righe, il tempo CPU utilizzando DateDiff può essere vicino a 1/3 del tempo Converti CPU!

Per visualizzare i piani di esecuzione per le query:

set showplan_text on
GO 

Sia DATEADD che DATEDIFF eseguiranno CONVERT_IMPLICIT.

Sebbene la soluzione CONVERT sia più semplice e più facile da leggere per alcuni, è più lenta. Non è necessario eseguire il cast al datetime (ciò è implicitamente fatto dal server). Non è inoltre necessario il metodo DateDiff per DateAdd in seguito, poiché anche il risultato intero verrà convertito in modo implicito in datetime.

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

SELEZIONA DATEADD (gg, 0, DATEDIFF (gg, 0, MyDate)) DA DateTabella

  |--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 è consigliabile poiché il cast del tipo di dati datetime su float e back non sempre restituisce il valore originale.

Ricorda ragazzi: non credete a nessuno. Guarda le statistiche sulle prestazioni e provale tu stesso!

Fai attenzione quando collaudi i tuoi risultati. La selezione di più righe per il client nasconderà la differenza di prestazioni perché impiega più tempo a inviare le righe sulla rete di quanto non faccia per eseguire i calcoli. Quindi assicurati che il lavoro per tutte le righe sia svolto dal server ma che non ci siano set di righe inviati al client.

Sembra esserci 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. Quindi puoi far scadere 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 lo desideri, esegui l'esecuzione n.

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

Prova questo:

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

La suddetta dichiarazione converte il formato corrente in YYYY/MM/DD, fare riferimento a questo collegamento per scegliere il formato preferibile.

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

Per tornare in formato data

CAST (Data ordine Data AS)

Il codice sopra funzionerà in SQL Server 2010

Tornerà come il 12/12/2013

Per SQL Server 2012 utilizzare il codice seguente

CONVERT(VARCHAR(10), OrderDate , 111)

È possibile utilizzare la CONVERTfunzione per restituire solo la data. Vedi i link qui sotto:

Manipolazione di data e ora in SQL Server 2000

CAST e CONVERT

La sintassi per l'utilizzo della funzione di conversione è:

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

Se hai bisogno del risultato come a varchar, dovresti passare attraverso

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

che è già menzionato sopra.

Se hai bisogno di risultati nel formato di data e ora, dovresti usare una qualsiasi delle domande qui sotto

1. SELECT CONVERT(DATETIME, CONVERT(VARCHAR(10), GETDATE(), 111)) AS OnlyDate 

   26-03-2014 00: 00: 00.000

2. SELECT CONVERT(DATETIME, CONVERT(VARCHAR(10), GETDATE(), 112)) AS OnlyDate 

   26-03-2014 00: 00: 00.000

3. DECLARE  @OnlyDate DATETIME
   SET @OnlyDate = DATEDIFF(DD, 0, GETDATE())
   SELECT @OnlyDate AS OnlyDate

   26-03-2014 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 tagliare la parte del tempo.

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

Se si utilizza SQL Server 2012 o versioni successive ,

Usa la Format()funzione.

Esistono già più risposte e tipi di formattazione per il server SQL. Ma la maggior parte dei metodi sono in qualche modo ambigui e sarebbe difficile ricordare i numeri per tipo di formato o funzioni rispetto al Formato data specifico. Ecco perché nelle prossime versioni di SQL Server c'è un'opzione migliore.

FORMAT ( value, format [, culture ] )

L'opzione Cultura è molto utile, poiché puoi specificare la data secondo i tuoi spettatori.

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

1. "d" - modello di 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 di 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 in 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 a:

1. Stringhe di formato di data e ora standard
2. Stringhe di formato di data e ora personalizzate

Se si desidera utilizzare CONVERT e ottenere lo stesso output della domanda originale posta, ovvero yyyy-mm-dd, utilizzare lo CONVERT(varchar(10),[SourceDate as dateTime],121)stesso codice della risposta della coppia precedente, ma il codice da convertire in yyyy-mm-dd con trattini è 121.

Se riesco ad accedere al mio soapbox per un secondo, questo tipo di formattazione non appartiene al livello dei dati , ed è per questo che non è stato possibile senza "trucchi" stupidi per le spese generali fino a SQL Server 2008 quando i tipi di dati di datepart effettivi sono introdotto. Effettuare tali conversioni nel livello dati è un enorme spreco di sovraccarico per il tuo DBMS, ma ancora più importante, nel momento in cui fai qualcosa del genere, hai praticamente creato dati orfani in memoria che presumo che tornerai a un programma. Non è possibile rimetterlo in un'altra colonna 3NF + o confrontarlo con qualsiasi cosa digitata senza ripristinare, quindi tutto ciò che hai fatto è stato introdotto punti di errore e rimosso il riferimento relazionale.

Dovresti SEMPRE andare avanti e restituire il tipo di dati dateTime al programma chiamante e, nel livello PRESENTAZIONE, apportare le modifiche necessarie. Non appena vai a convertire le cose prima di restituirle al chiamante, rimuovi tutte le speranze di integrità referenziale dall'applicazione. Ciò impedirebbe di nuovo un'operazione di AGGIORNAMENTO o ELIMINAZIONE, a meno che non si esegua una sorta di inversione manuale, che espone nuovamente i dati all'errore umano / code / gremlin quando non è necessario.

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 out esegue il metodo convert in varchar.

Per ottenere il risultato indicato, utilizzo il seguente comando.

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

Lo olpe è utile.

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

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

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

DECLARE @Date DATE = GETDATE()   

SELECT @Date   --> 2017-05-03

Penso che funzionerebbe nel tuo 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, anche se sono un po 'in ritardo :), ecco un'altra soluzione.

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

Risultato

2008-09-22 00:00:00.000

E se si utilizza SQL Server 2012 e versioni successive, è possibile utilizzare la FORMAT()funzione in 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 qualunque formato di data 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 questo output:

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

Data:

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

Tempo:

SELEZIONA CONVERT (ora, GETDATE (), 114)
SELEZIONA CAST (GETDATE () come ora)

Semplicemente puoi fare così:

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

Uscite come:

2008-09-22 00:00:00.000

O semplicemente fai così:

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

Risultato:

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

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

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

è possibile modificare la sequenza di m, d e l'anno riordinando la '%d-%m-%Y'parte

So che questo è 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 positivo se Microsoft potesse supportare anche la variabile CURRENT_DATE standard ANSI.

Prediligo quanto segue che non è stato menzionato:

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

Inoltre, non si preoccupa del locale o non esegue una doppia conversione, anche se ogni 'datepart' probabilmente fa matematica. Quindi potrebbe essere un po 'più lento del metodo datiff, ma per me è molto più chiaro. Soprattutto quando voglio raggruppare solo l'anno e il mese (impostare il giorno su 1).

A partire da SQL SERVER 2012, è possibile effettuare questa operazione:

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)

In questo caso, solo per la data, eseguiremo questa query:

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

È possibile utilizzare quanto segue per la parte della data e la formattazione della data:

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

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

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

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