Retouren: 2008-09-22 15:24:13.790
Ik wil dat datumgedeelte zonder het tijdgedeelte: 2008-09-22 00:00:00.000
Hoe kan ik dat krijgen?
Antwoord 1, autoriteit 100%
Op SQL Server 2008 en hoger moet u tot nu toe CONVERT:
SELECT CONVERT(date, getdate())
In oudere versies kunt u het volgende doen:
SELECT DATEADD(dd, 0, DATEDIFF(dd, 0, @your_date))
bijvoorbeeld
SELECT DATEADD(dd, 0, DATEDIFF(dd, 0, GETDATE()))
geeft me
2008-09-22 00:00:00.000
Pluspunten:
- Geen
varchar<->datetimeconversies vereist - Je hoeft niet na te denken over
locale
Zoals voorgesteld door Michael
Gebruik deze variant: 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()))
Uitvoer:
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
Antwoord 2, autoriteit 28%
SQLServer 2008 heeft nu een datatype ‘datum’ dat alleen een datum zonder tijdcomponent bevat. Iedereen die SQLServer 2008 en hoger gebruikt, kan het volgende doen:
SELECT CONVERT(date, getdate())
Antwoord 3, autoriteit 7%
Bij gebruik van SQL 2008 en hoger:
select cast(getdate() as date)
Antwoord 4, autoriteit 3%
DATEADD en DATEDIFF zijn beter dan CONVERTEN naar varchar. Beide query’s hebben hetzelfde uitvoeringsplan, maar uitvoeringsplannen hebben voornamelijk betrekking op toegangsstrategieën voor gegevens en onthullen niet altijd de impliciete kosten die gemoeid zijn met de CPU-tijd die nodig is om alle onderdelen uit te voeren. Als beide query’s worden uitgevoerd op een tabel met miljoenen rijen, kan de CPU-tijd met DateDiff bijna 1/3 van de CPU-conversietijd bedragen!
Om uitvoeringsplannen voor zoekopdrachten te zien:
set showplan_text on
GO
Zowel DATEADD als DATEDIFF voeren een CONVERT_IMPLICIT uit.
Hoewel de CONVERT-oplossing voor sommigen eenvoudiger en gemakkelijker te lezen is, is deze is langzamer. Het is niet nodig om terug te casten naar datetime (dit wordt impliciet gedaan door de server). Het is ook niet echt nodig in de DateDiff-methode voor DateAdd achteraf, omdat het integer-resultaat ook impliciet terug naar datetime wordt geconverteerd.
SELECTEER CONVERT(varchar, MijnDatum, 101) UIT DatumsTabel
|--Compute Scalar(DEFINE:([Expr1004]=CONVERT(varchar(30),[TEST].[dbo].[DatesTable].[MyDate],101)))
|--Table Scan(OBJECT:([TEST].[dbo].[DatesTable]))
SELECTEER DATEADD(dd, 0, DATEDIFF(dd, 0, MijnDatum)) UIT Datumtabel
|--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]))
Het gebruik van FLOOR() zoals @digi suggereerde heeft prestaties dichter bij DateDiff, maar wordt niet aanbevolen omdat het casten van het datatype datetime naar float en terug niet altijd de oorspronkelijke waarde oplevert.
Onthoud jongens: geloof niemand. Bekijk de prestatiestatistieken en test het zelf!
Wees voorzichtig wanneer u uw resultaten test. Als u veel rijen naar de client selecteert, wordt het prestatieverschil verborgen, omdat het langer duurt om de rijen over het netwerk te verzenden dan om de berekeningen uit te voeren. Zorg er dus voor dat het werk voor alle rijen door de server wordt gedaan, maar dat er geen rijenset naar de client wordt verzonden.
Sommige mensen lijken verwarring te hebben over wanneer cache-optimalisatie van invloed is op zoekopdrachten. Het uitvoeren van twee query’s in dezelfde batch of in afzonderlijke batches heeft geen effect op caching. U kunt de cache dus handmatig laten verlopen of de query’s eenvoudig meerdere keren heen en weer uitvoeren. Elke optimalisatie voor query #2 zou ook van invloed zijn op eventuele volgende query’s, dus gooi uitvoering #1 weg als u wilt.
Hier is volledig testscript en prestatieresultaten die bewijzen dat DateDiff aanzienlijk sneller is dan converteren naar varchar.
Antwoord 5, autoriteit 2%
Probeer dit:
SELECT CONVERT(VARCHAR(10),GETDATE(),111)
De bovenstaande verklaring converteert uw huidige indeling naar YYYY/MM/DD, raadpleeg deze link om het gewenste formaat te kiezen.
Antwoord 6, autoriteit 2%
SELECT CONVERT(datetime, CONVERT(varchar, GETDATE(), 101))
Antwoord 7
Voor teruggave in datumnotatie
CAST(OrderDatum AS-datum)
De bovenstaande code werkt in sql server 2010
Het komt terug zoals 12/12/2013
Gebruik voor SQL Server 2012 de onderstaande code
CONVERT(VARCHAR(10), OrderDate , 111)
Antwoord 8
U kunt de functie CONVERT gebruiken om alleen de datum te retourneren. Zie de link(s) hieronder:
Datum- en tijdmanipulatie in SQL Server 2000
De syntaxis voor het gebruik van de convert-functie is:
CONVERT ( data_type [ ( length ) ] , expression [ , style ] )
Antwoord 9
Als je het resultaat als een varchar nodig hebt, ga je door
SELECT CONVERT(DATE, GETDATE()) --2014-03-26
SELECT CONVERT(VARCHAR(10), GETDATE(), 111) --2014/03/26
wat hierboven al genoemd is.
Als u resultaten in datum- en tijdnotatie nodig heeft, kunt u een van de onderstaande zoekopdrachten gebruiken
-
SELECT CONVERT(DATETIME, CONVERT(VARCHAR(10), GETDATE(), 111)) AS OnlyDate26-03-2014 00:00:00.000
-
SELECT CONVERT(DATETIME, CONVERT(VARCHAR(10), GETDATE(), 112)) AS OnlyDate26-03-2014 00:00:00.000
-
DECLARE @OnlyDate DATETIME SET @OnlyDate = DATEDIFF(DD, 0, GETDATE()) SELECT @OnlyDate AS OnlyDate26-03-2014 00:00:00.000
Antwoord 10
Als u SQL Server 2012 of hogere versies gebruikt,
Gebruik FORMAT()-functie .
Er zijn al meerdere antwoorden en opmaaktypen voor SQL-server.
Maar de meeste methoden zijn enigszins dubbelzinnig en het zou voor u moeilijk zijn om de getallen voor het formaattype of functies met betrekking tot het specifieke datumformaat te onthouden. Daarom is er in de volgende versies van SQL Server een betere optie.
FORMAT ( value, format [, culture ] )
Cultuuroptie is erg handig, omdat je de datum kunt specificeren volgens je kijkers.
Je moet d (voor kleine patronen) en D (voor lange patronen) onthouden.
1.”d” – Kort datumpatroon.
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” – Lange datumpatroon.
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)
Meer voorbeelden in zoekopdracht.
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?
Als u meer indelingen wilt, kunt u naar:
- Standaard tekenreeksen voor datum- en tijdnotatie
- Aangepaste tekenreeksen voor datum- en tijdnotatie
Antwoord 11
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
Antwoord 12
VLOER() gebruiken – verkort gewoon de tijd.
SELECT CAST(FLOOR(CAST(GETDATE() AS FLOAT)) AS DATETIME)
Antwoord 13
ALS je CONVERT wilt gebruiken en dezelfde output wilt krijgen als in de oorspronkelijke vraag, dat wil zeggen, jjjj-mm-dd, gebruik dan CONVERT(varchar(10),[SourceDate as dateTime],121) dezelfde code als het vorige paar antwoordt, maar de code die moet worden geconverteerd naar jjjj-mm-dd met streepjes is 121.
Als ik even op mijn zeepkist kan, dit soort opmaak hoort niet thuis in de datalaag, en daarom was het niet mogelijk zonder dwaze ‘trucjes’ met hoge overhead tot SQL Server 2008 toen de feitelijke datatypes voor datumdelen werden geïntroduceerd. Het maken van dergelijke conversies in de datalaag is een enorme verspilling van overhead op uw DBMS, maar wat nog belangrijker is, de tweede keer dat u zoiets doet, heeft u in feite verweesde gegevens in het geheugen gemaakt waarvan ik aanneem dat u daarna terugkeert naar een programma. Je kunt het niet terugzetten in een andere 3NF+-kolom of het vergelijken met iets getypt zonder terug te keren, dus alles wat je hebt gedaan is faalpunten geïntroduceerd en relationele verwijzingen verwijderd.
Je moet ALTIJD doorgaan en je dateTime-gegevenstype terugsturen naar het aanroepende programma en in de PRESENTATION-laag de nodige aanpassingen maken. Zodra je gaat converteren voordat u ze terugstuurt naar de beller, verwijdert u alle hoop op referentiële integriteit uit de toepassing. Dit zou opnieuw een UPDATE- of DELETE-bewerking voorkomen, tenzij u een soort van handmatige reversie uitvoert, waardoor uw gegevens opnieuw worden blootgesteld aan menselijke/code/gremlin-fouten wanneer dat niet nodig is.
Antwoord 14
SELECT DATEADD(DD, DATEDIFF(DD, 0, GETDATE()), 0)
SELECT DATEADD(DAY, 0, DATEDIFF(DAY,0, GETDATE()))
SELECT CONVERT(DATETIME, CONVERT(VARCHAR(10), GETDATE(), 101))
Bewerken: de eerste twee methoden zijn in wezen hetzelfde en voeren de methode converteren naar varchar uit.
Antwoord 15
Om het aangegeven resultaat te verkrijgen, gebruik ik de volgende opdracht.
SELECT CONVERT(DATETIME,CONVERT(DATE,GETDATE()))
Ik hoop dat het nuttig is.
Antwoord 16
Convert(nvarchar(10), getdate(), 101) ---> 5/12/14
Convert(nvarchar(12), getdate(), 101) ---> 5/12/2014
Antwoord 17
Als u de resultaten aan een kolom of variabele toewijst, geeft u deze het type DATE en de conversie is impliciet.
DECLARE @Date DATE = GETDATE()
SELECT @Date --> 2017-05-03
Antwoord 18
In dit geval, alleen de datum, gaan we deze zoekopdracht uitvoeren:
SELECT CONVERT(VARCHAR(10), getdate(), 111);
Antwoord 19
Ik denk dat dit in jouw geval zou werken:
CONVERT(VARCHAR(10),Person.DateOfBirth,111) AS BirthDate
//here date is obtained as 1990/09/25
Antwoord 20
DECLARE @yourdate DATETIME = '11/1/2014 12:25pm'
SELECT CONVERT(DATE, @yourdate)
Antwoord 21
Oké, hoewel ik een beetje laat ben :), Hier is de andere oplossing.
SELECT CAST(FLOOR(CAST(GETDATE() AS FLOAT)) AS DATETIME)
Resultaat
2008-09-22 00:00:00.000
En als u SQL Server 2012 en hoger gebruikt, kunt u de functie FORMAT() als volgt gebruiken –
SELECT FORMAT(GETDATE(), 'yyyy-MM-dd')
Antwoord 22
Datum:
SELECTEER CONVERTEREN(datum, GETDATUM()) SELECTEER CAST(GETDATE() als datum)
Tijd:
SELECTEER CONVERTEREN(tijd , GETDATUM() , 114) SELECTEER CAST(GETDATE() als tijd)
Antwoord 23
Zelfs bij gebruik van de oude MSSQL Server 7.0, de code hier (met dank aan deze link) stelde me in staat om het datumformaat te krijgen dat ik op dat moment zocht:
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)
Het produceerde deze uitvoer:
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
Antwoord 24
Je kunt het gewoon op deze manier doen:
SELECT CONVERT(date, getdate())
SELECT DATEADD(dd, 0, DATEDIFF(dd, 0, @your_date))
SELECT DATEADD(dd, 0, DATEDIFF(dd, 0, GETDATE()))
Uitvoer als:
2008-09-22 00:00:00.000
Of doe gewoon zo:
SELECT CONVERT (DATE, GETDATE()) 'Date Part Only'
Resultaat:
Date Part Only
--------------
2013-07-14
Antwoord 25
Doe gewoon:
SELECT CAST(date_variable AS date)
of met met PostgreSQL:
SELECT date_variable::date
Antwoord 26
waarom gebruikt u DATE_FORMAT( uw_datetiem_column, ‘%d-%m-%Y’ ) niet?
EX: select DATE_FORMAT( some_datetime_column, '%d-%m-%Y' ) from table_name
je kunt de volgorde van m,d en jaar veranderen door het '%d-%m-%Y' gedeelte
te herschikken
Antwoord 27
Ik weet dat dit oud is, maar ik zie niet waar iemand het op deze manier heeft gezegd. Voor zover ik kan zien, is dit de ANSI-standaard.
SELECT CAST(CURRENT_TIMESTAMP AS DATE)
Het zou goed zijn als Microsoft ook de ANSI-standaard CURRENT_DATE-variabele zou kunnen ondersteunen.
Antwoord 28
Ik geef de voorkeur aan het volgende dat niet werd genoemd:
DATEFROMPARTS(DATEPART(yyyy, @mydatetime), DATEPART(mm, @mydatetime), DATEPART(dd, @mydatetime))
Het geeft ook niet om lokale of dubbele conversie — hoewel elk ‘datepart’ waarschijnlijk rekent. Dus het is misschien iets langzamer dan de datediff-methode, maar voor mij is het veel duidelijker. Vooral als ik alleen op jaar en maand wil groeperen (zet de dag op 1).
Antwoord 29
Vanaf SQL SERVER 2012 kunt u dit doen:
SELECT FORMAT(GETDATE(), 'yyyy-MM-dd 00:00:00.000')
Antwoord 30
Op SQL Server 2000
CAST(
(
STR( YEAR( GETDATE() ) ) + '/' +
STR( MONTH( GETDATE() ) ) + '/' +
STR( DAY( GETDATE() ) )
)
AS DATETIME)