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

StackOverflow https://stackoverflow.com/questions/113045

Domanda 

SELECT GETDATE()

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

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

Come posso ottenere che?

È stato utile?

Soluzione

Su SQL Server 2008 e versioni successive, dovresti CONVERT ad oggi: 

SELECT CONVERT(date, getdate())

Nelle versioni precedenti, puoi eseguire le seguenti operazioni: 

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

ad esempio 

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

mi dà 

2008-09-22 00:00:00.000

Pro:

  • No varchar < - > datetime conversioni richieste
  • Non c'è bisogno di pensare a locale

Come suggerito da Michael

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

Altri suggerimenti

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 di CPU impiegato 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 di conversione della CPU!

Per visualizzare 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 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 (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 è 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 sul rendimento e provalo tu stesso!

Fai attenzione quando collaudi i tuoi risultati. La selezione di più righe per il client nasconderà la differenza di prestazioni poiché 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 vi 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, elimina l'esecuzione n. 1

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

Prova questo: 

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

L'istruzione precedente converte il formato corrente in YYYY/MM/DD, fare riferimento a questo link per scegliere il formato preferibile. 

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

È possibile utilizzare la funzione CONVERT 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'uso della funzione di conversione è: 

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

Per il ritorno 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)

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

Uso di 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() .

Esistono già più risposte e tipi di formattazione per SQL Server. Ma la maggior parte dei metodi sono in qualche modo ambigui e sarebbe difficile ricordare i numeri per il tipo di formato o le 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 quot. &; & D quot; - 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 quot. &; & D quot; - 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 su:

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

SE vuoi usare CONVERT e ottenere lo stesso output della domanda originale posta, cioè yyyy-mm-dd quindi usa CONVERT(varchar(10),[SourceDate as dateTime],121) lo stesso codice delle risposte 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 dati , ed è per questo che non sarebbe stato possibile senza "trucchi" stupidi per sovraccarico fino a SQL Server 2008 quando vengono introdotti i tipi di dati di datepart effettivi. Effettuare tali conversioni nel livello dati è un enorme spreco di sovraccarico sul tuo DBMS, ma, soprattutto, nel momento in cui fai qualcosa del genere, hai praticamente creato dati orfani in memoria che presumo che poi tornerai a un programma. Non puoi reinserirlo 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 tutte le modifiche necessarie. Non appena esegui la conversione cose prima di restituirle al chiamante, stai rimuovendo ogni speranza 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 human / 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 fuori eseguono il metodo convert in varchar.

Per ottenere il risultato indicato, utilizzo il seguente comando. 

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

Lo olpe è utile.

Se hai bisogno di ottenere il tipo di dati varchar, dovresti passare 

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

che è già stato menzionato sopra

Se hai bisogno di risultati nel formato di data e ora, dovresti passare attraverso una delle seguenti query

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 

 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 DATE 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

Va bene, Se fossi un po ' in ritardo :), Qui è 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 superiore, quindi è possibile utilizzare FORMAT() funzione come questa -

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 il formato 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 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

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

Data: 

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

Ora: 

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

Preferisco quanto segue che non è stato menzionato: 

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

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

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)

Semplicemente puoi farlo in questo modo: 

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

Output 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

puoi cambiare la sequenza di m, d e anno riordinando '%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.

Questo mancava in tutte le risposte, potrebbe non essere il più efficiente ma molto facile da scrivere e comprendere, senza stile necessario, senza funzioni di data complesse. 

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

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

DATENAME = > Restituisce una stringa di caratteri che rappresenta la parte 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, minuti, ecc.

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

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

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top