Related
Sep-19 (MONTH-YEAR) - varchar
String and what I need to do is change that to:
September 30, 2019 (MONTH DAY(LAST DAY OF THE MONTH),YEAR) varchar
I am working with SQL server 2014.
Any suggestion?
Really, you shouldn't be storing or accepting dates in this format.
But given that you already are, and undoubtedly the response will be that you can't fix it, you can use style 6 (dd MMM yy) and some string manipulation to revert this format back to a proper date. But you have to make sure your language settings match the way the data is stored:
SET LANGUAGE us_english;
DECLARE #my char(6) = 'Sep-19';
SELECT EOMONTH(CONVERT(date, REPLACE('01 '+#my,'-',' '), 6));
I'm really not a big fan of EOMONTH() as this is about the only useful application of it. In my own code I would probably use something like this, even though it's more verbose:
SELECT DATEADD(DAY, -1, DATEADD(MONTH, 1, CONVERT(date, REPLACE('01 '+#my,'-',' '), 6)));
This should work:
select eomonth(cast('01-' + month_year as date))
I'm not a fan of 2 digit years, but this should work for many examples of years.
There are already qite a few good answers, but I'd like to add mine anyway:
declare #input as nvarchar(100) = 'Sep-19'
select FORMAT(EOMONTH(PARSE(LEFT(#input, 3) + '-01-' + RIGHT(#input, 2) as datetime using 'En-Us')), 'MMMM dd, yyyy')
The output is: "September 30, 2019"
I am trying to convert an nvarchar date into a date time, but this error occurs: I have tried multiple ways including CAST and Convert (as code below) with no avail. Any suggestions ?
Date Format : Wed, 19 Jul 2017 16:23:38 +0000
Code:
INSERT INTO feed.article(title,link,sourceID,[date])
SELECT title,link,s.sourceID,
CONVERT(DATETIME,[date],121)
FROM feed.tempXML t
JOIN feed.[source] s ON s.sourceName = t.[source]
Error given:
Conversion failed when converting date and/or time from character string.
If you have MS SQL Server 2012 or higher, you may use TRY_PARSE.
SELECT CAST(TRY_PARSE ('Wed, 19 Jul 2017 16:23:38 +0000' AS datetimeoffset) AS datetime)
I would do this in two parts, one for the date and one for the time:
SELECT title,link,s.sourceID,
(CONVERT(DATETIME, SUBSTRING([date], 5, 10), 106) +
CONVERT(DATETIME, SUBSTRING([date], 18, 8))
)
FROM feed.tempXML t JOIN
feed.[source] s
ON s.sourceName = t.[source];
This minimizes the string operations, so it seems like a pretty simple approach.
EDIT: Check out the solutions by Oleg and Gordon. I actually prefer them both to my own (as it's quite convoluted).
You need to get your date format from this...
'Wed, 19 Jul 2017 16:23:38 +0000'
...to this...
'19 Jul 2017 16:23:38'
You can remove chars from the beginning and end using LEFT and RIGHT. Removing the last 6 from the end would look like this:
LEFT([date], LEN[date] - 6)
We can use the same syntax for our RIGHT() to remove the first 5, but [date] must now be replaced with the entire string from above:
-- RIGHT([date], LEN([date]) - 5) becomes...
RIGHT(LEFT(#d, LEN(#d) - 6), LEN(LEFT(#d, LEN(#d) - 6)) - 5)
All in all, it's ugly, but works:
INSERT INTO feed.article(title,link,sourceID,[date])
SELECT title,link,s.sourceID,
CONVERT(DATETIME,RIGHT(LEFT([date], LEN([date]) - 6), LEN(LEFT([date], LEN([date]) - 6)) - 5),121)
FROM feed.tempXML t
JOIN feed.[source] s ON s.sourceName = t.[source]
IMPORTANT NOTE: This is under the assumption that the format of your date will always have 5 unnecessary characters at the beginning, and that your timezone offset (the +0000 at the end) will always be 0 (so we can simply ignore it).
If you'll have values that make use of the timezone offset, you'll need to account for that.
Based on the format, we should be able make a few "safe assumptions"...
1) The weekday will always be expressed as a 3 char abbreviation.
2) The 3 char abbreviation will be followed by a comma and a space.
3) The portion of code we're interested in will be either 19 or 20 characters.
(10 for single digit dates and 20 for double digit dates)
4) There will be a space following the date.
Based on these assumptions, you should be safe to use the following...
CREATE TABLE #TestData (
StringDate NVARCHAR(40) NOT NULL
);
INSERT #TestData (StringDate) VALUES
(N'Wed, 19 Jul 2017 16:23:38 +0000'),
(N'Wed, 9 Jul 2017 16:23:38 +0000');
SELECT
DateTimeDate = CAST(SUBSTRING(td.StringDate, 6, 20) AS DATETIME)
FROM
#TestData td;
SELECT GETDATE()
Returns: 2008-09-22 15:24:13.790
I want that date part without the time part: 2008-09-22 00:00:00.000
How can I get that?
SELECT DATEADD(dd, 0, DATEDIFF(dd, 0, #your_date))
for example
SELECT DATEADD(dd, 0, DATEDIFF(dd, 0, GETDATE()))
gives me
2008-09-22 00:00:00.000
Pros:
No varchar<->datetime conversions required
No need to think about locale
SQLServer 2008 now has a 'date' data type which contains only a date with no time component. Anyone using SQLServer 2008 and beyond can do the following:
SELECT CONVERT(date, GETDATE())
If using SQL 2008 and above:
select cast(getdate() as date)
DATEADD and DATEDIFF are better than CONVERTing to varchar. Both queries have the same execution plan, but execution plans are primarily about data access strategies and do not always reveal implicit costs involved in the CPU time taken to perform all the pieces. If both queries are run against a table with millions of rows, the CPU time using DateDiff can be close to 1/3rd of the Convert CPU time!
To see execution plans for queries:
set showplan_text on
GO
Both DATEADD and DATEDIFF will execute a CONVERT_IMPLICIT.
Although the CONVERT solution is simpler and easier to read for some, it is slower. There is no need to cast back to DateTime (this is implicitly done by the server). There is also no real need in the DateDiff method for DateAdd afterward as the integer result will also be implicitly converted back to 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]))
Using FLOOR() as #digi suggested has performance closer to DateDiff, but is not recommended as casting the DateTime data type to float and back does not always yield the original value.
Remember guys: Don't believe anyone. Look at the performance statistics, and test it yourself!
Be careful when you're testing your results. Selecting many rows to the client will hide the performance difference because it takes longer to send the rows over the network than it does to perform the calculations. So make sure that the work for all the rows is done by the server but there is no row set sent to the client.
There seems to be confusion for some people about when cache optimization affects queries. Running two queries in the same batch or in separate batches has no effect on caching. So you can either expire the cache manually or simply run the queries back and forth multiple times. Any optimization for query #2 would also affect any subsequent queries, so throw out execution #1 if you like.
Here is full test script and performance results that prove DateDiff is substantially faster than converting to varchar.
Try this:
SELECT CONVERT(VARCHAR(10),GETDATE(),111)
The above statement converts your current format to YYYY/MM/DD, please refer to this link to choose your preferable format.
SELECT CONVERT(datetime, CONVERT(varchar, GETDATE(), 101))
For return in date format
CAST(OrderDate AS date)
The above code will work in sql server 2010
It will return like 12/12/2013
For SQL Server 2012 use the below code
CONVERT(VARCHAR(10), OrderDate , 111)
Just do:
SELECT CAST(date_variable AS date)
or with with PostgreSQL:
SELECT date_variable::date
This is called typecasting btw!
You can use the CONVERT function to return only the date. See the link(s) below:
Date and Time Manipulation in SQL Server 2000
CAST and CONVERT
The syntax for using the convert function is:
CONVERT ( data_type [ ( length ) ] , expression [ , style ] )
If you need the result as a varchar, you should go through
SELECT CONVERT(DATE, GETDATE()) --2014-03-26
SELECT CONVERT(VARCHAR(10), GETDATE(), 111) --2014/03/26
which is already mentioned above.
If you need result in date and time format, you should use any of the queries below
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
If you are using SQL Server 2012 or above versions,
Use Format() function.
There are already multiple answers and formatting types for SQL server.
But most of the methods are somewhat ambiguous and it would be difficult for you to remember the numbers for format type or functions with respect to Specific Date Format. That's why in next versions of SQL server there is better option.
FORMAT ( value, format [, culture ] )
Culture option is very useful, as you can specify date as per your viewers.
You have to remember d (for small patterns) and D (for long patterns).
1."d" - Short date pattern.
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" - Long date pattern.
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)
More examples 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日
If you want more formats, you can go to:
Standard Date and Time Format Strings
Custom Date and Time Format Strings
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
Using FLOOR() - just cut time part.
SELECT CAST(FLOOR(CAST(GETDATE() AS FLOAT)) AS DATETIME)
To obtain the result indicated, I use the following command.
SELECT CONVERT(DATETIME,CONVERT(DATE,GETDATE()))
I holpe it is useful.
IF you want to use CONVERT and get the same output as in the original question posed, that is, yyyy-mm-dd then use CONVERT(varchar(10),[SourceDate as dateTime],121) same code as the previous couple answers, but the code to convert to yyyy-mm-dd with dashes is 121.
If I can get on my soapbox for a second, this kind of formatting doesn't belong in the data tier, and that's why it wasn't possible without silly high-overhead 'tricks' until SQL Server 2008 when actual datepart data types are introduced. Making such conversions in the data tier is a huge waste of overhead on your DBMS, but more importantly, the second you do something like this, you have basically created in-memory orphaned data that I assume you will then return to a program. You can't put it back in to another 3NF+ column or compare it to anything typed without reverting, so all you've done is introduced points of failure and removed relational reference.
You should ALWAYS go ahead and return your dateTime data type to the calling program and in the PRESENTATION tier, make whatever adjustments are necessary. As soon as you go converting things before returning them to the caller, you are removing all hope of referential integrity from the application. This would prevent an UPDATE or DELETE operation, again, unless you do some sort of manual reversion, which again is exposing your data to human/code/gremlin error when there is no need.
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: The first two methods are essentially the same, and out perform the convert to varchar method.
If you are assigning the results to a column or variable, give it the DATE type, and the conversion is implicit.
DECLARE #Date DATE = GETDATE()
SELECT #Date --> 2017-05-03
Convert(nvarchar(10), getdate(), 101) ---> 5/12/14
Convert(nvarchar(12), getdate(), 101) ---> 5/12/2014
Date:
SELECT CONVERT(date, GETDATE())
SELECT CAST(GETDATE() as date)
Time:
SELECT CONVERT(time , GETDATE() , 114)
SELECT CAST(GETDATE() as time)
Syntax:
SELECT CONVERT (data_type(length)),Date, DateFormatCode)
Ex:
Select CONVERT(varchar,GETDATE(),1) as [MM/DD/YY]
Select CONVERT(varchar,GETDATE(),2) as [YY.MM.DD]
all dateformatcodes about Date:
DateFormatCode Format
1 [MM/DD/YY]
2 [YY.MM.DD]
3 [DD/MM/YY]
4 [DD.MM.YY]
5 [DD-MM-YY]
6 [DD MMM YY]
7 [MMM DD,YY]
10 [MM-DD-YY]
11 [YY/MM/DD]
12 [YYMMDD]
23 [yyyy-mm-dd]
101 [MM/DD/YYYY]
102 [YYYY.MM.DD]
103 [DD/MM/YYYY]
104 [DD/MM/YYYY]
105 [DD/MM/YYYY]
106 [DD MMM YYYY]
107 [MMM DD,YYYY]
110 [MM-DD-YYYY]
111 [YYYY/MM/DD]
112 [YYYYMMDD]
Simply you can do this way:
SELECT CONVERT(date, getdate())
SELECT DATEADD(dd, 0, DATEDIFF(dd, 0, #your_date))
SELECT DATEADD(dd, 0, DATEDIFF(dd, 0, GETDATE()))
Outputs as:
2008-09-22 00:00:00.000
Or simply do like this:
SELECT CONVERT (DATE, GETDATE()) 'Date Part Only'
Result:
Date Part Only
--------------
2013-07-14
In this case, date only, you we are gonna run this query:
SELECT CONVERT(VARCHAR(10), getdate(), 111);
I think this would work in your case:
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)
Okay, Though I'm bit late :), Here is the another solution.
SELECT CAST(FLOOR(CAST(GETDATE() AS FLOAT)) as DATETIME)
Result
2008-09-22 00:00:00.000
And if you are using SQL Server 2012 and higher then you can use FORMAT() function like this -
SELECT FORMAT(GETDATE(), 'yyyy-MM-dd')
Starting from SQL SERVER 2012, you can do this:
SELECT FORMAT(GETDATE(), 'yyyy-MM-dd 00:00:00.000')
Even using the ancient MSSQL Server 7.0, the code here (courtesy of this link) allowed me to get whatever date format I was looking for at the time:
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)
It produced this 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
why don't you use DATE_FORMAT( your_datetiem_column, '%d-%m-%Y' ) ?
EX: select DATE_FORMAT( some_datetime_column, '%d-%m-%Y' ) from table_name
you can change sequence of m,d and year by re-arranging '%d-%m-%Y' part
I know this is old, but I do not see where anyone stated it this way. From what I can tell, this is ANSI standard.
SELECT CAST(CURRENT_TIMESTAMP AS DATE)
It would be good if Microsoft could also support the ANSI standard CURRENT_DATE variable.
I favor the following which wasn't mentioned:
DATEFROMPARTS(DATEPART(yyyy, #mydatetime), DATEPART(mm, #mydatetime), DATEPART(dd, #mydatetime))
It also doesn't care about local or do a double convert -- although each 'datepart' probably does math. So it may be a little slower than the datediff method, but to me it is much more clear. Especially when I want to group by just the year and month (set the day to 1).
I have a varchar variable containing value 01 May 2013 and I need to obtain the integer of the Month part.
for eg if 01 May 2013 is input I should get the result as 5
The query I wrote was :
select DATEPART(MM,CONVERT(DATETIME,CONVERT(VARCHAR(15),'01 '+SUBSTRING(FISCAL_MONTH,1,3)+' 2013'),100))
FROM <table name>
Here FISCAL_MONTH is my column name from the table. However this query is showing me the result, for eg 11 for November but is also throwing the following error :
Msg 241, Level 16, State 1, Line 1
Conversion failed when converting date and/or time from character string.
I have tried various combinations, bit in vain. Kindly note I need it in a query. Kindly help.
If that is the only date you want to convert then you can simplify the SQL statement to:
select datepart(mm,convert(datetime,'01 May 2013'))
I just used this to test and it worked:
declare #t as varchar(333)
set #t = '01 May 2013'
select datepart(mm,convert(datetime, #t))
Gives me
5
If you are still getting that conversion error, then you either have some NULL values OR some date values that are not in the correct format. Check the data in your table to see which it is.
I'll leave it to you to add the rest of the months.
select case substring('01 MAY 2013',4,3) when 'JAN' then 1
when 'FEB' then 2
when 'MAR' then 3
when 'APR' then 4
when 'MAY' then 5
when 'JUN' then 6 else 9999 end
It might just be that there is a 3 instead of a 2 in the substring argument:
SUBSTRING(FISCAL_MONTH,1,2)+' 2013'),100))
The concat might work also:
select DATEPART(MM, CONCAT('01/', substring(convert(varchar(15),'03/23/2013'),1,2),'/2013'));
Wow, it is real interesting to see all the weird code that people come up with. I use the KISS policy most of the time (keep it simple stupid).
How about the MONTH() function. It has been in the TSQL language forever. I even threw in a coalesce to handle any unexpected NULLS.
-- Simple date as text
declare #var_test varchar(20) = '01 may 2013';
-- Use coalesce to handle nulls, use month to return int
select month(coalesce(#var_test, '01 jan 1900')) as my_month_index
Select month ( cast ( date_col as datetime ))
From table
You have to convert with proper format, you have to pass the apprpriate format-style value on your conversion. As per MSDN, you are using "dd mon yy" format, so you have to supply the corresponding format-style-code 6 or 106
Declare #FISCAL_MONTH nvarchar(max) = '01 May 2013'
select datepart(mm,Convert(datetime, #FISCAL_MONTH, 6))
--5
Set #FISCAL_MONTH = '01 November 2013'
select datepart(mm,Convert(datetime, #FISCAL_MONTH, 6))
--11
SELECT GETDATE()
Returns: 2008-09-22 15:24:13.790
I want that date part without the time part: 2008-09-22 00:00:00.000
How can I get that?
SELECT DATEADD(dd, 0, DATEDIFF(dd, 0, #your_date))
for example
SELECT DATEADD(dd, 0, DATEDIFF(dd, 0, GETDATE()))
gives me
2008-09-22 00:00:00.000
Pros:
No varchar<->datetime conversions required
No need to think about locale
SQLServer 2008 now has a 'date' data type which contains only a date with no time component. Anyone using SQLServer 2008 and beyond can do the following:
SELECT CONVERT(date, GETDATE())
If using SQL 2008 and above:
select cast(getdate() as date)
DATEADD and DATEDIFF are better than CONVERTing to varchar. Both queries have the same execution plan, but execution plans are primarily about data access strategies and do not always reveal implicit costs involved in the CPU time taken to perform all the pieces. If both queries are run against a table with millions of rows, the CPU time using DateDiff can be close to 1/3rd of the Convert CPU time!
To see execution plans for queries:
set showplan_text on
GO
Both DATEADD and DATEDIFF will execute a CONVERT_IMPLICIT.
Although the CONVERT solution is simpler and easier to read for some, it is slower. There is no need to cast back to DateTime (this is implicitly done by the server). There is also no real need in the DateDiff method for DateAdd afterward as the integer result will also be implicitly converted back to 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]))
Using FLOOR() as #digi suggested has performance closer to DateDiff, but is not recommended as casting the DateTime data type to float and back does not always yield the original value.
Remember guys: Don't believe anyone. Look at the performance statistics, and test it yourself!
Be careful when you're testing your results. Selecting many rows to the client will hide the performance difference because it takes longer to send the rows over the network than it does to perform the calculations. So make sure that the work for all the rows is done by the server but there is no row set sent to the client.
There seems to be confusion for some people about when cache optimization affects queries. Running two queries in the same batch or in separate batches has no effect on caching. So you can either expire the cache manually or simply run the queries back and forth multiple times. Any optimization for query #2 would also affect any subsequent queries, so throw out execution #1 if you like.
Here is full test script and performance results that prove DateDiff is substantially faster than converting to varchar.
Try this:
SELECT CONVERT(VARCHAR(10),GETDATE(),111)
The above statement converts your current format to YYYY/MM/DD, please refer to this link to choose your preferable format.
SELECT CONVERT(datetime, CONVERT(varchar, GETDATE(), 101))
For return in date format
CAST(OrderDate AS date)
The above code will work in sql server 2010
It will return like 12/12/2013
For SQL Server 2012 use the below code
CONVERT(VARCHAR(10), OrderDate , 111)
Just do:
SELECT CAST(date_variable AS date)
or with with PostgreSQL:
SELECT date_variable::date
This is called typecasting btw!
You can use the CONVERT function to return only the date. See the link(s) below:
Date and Time Manipulation in SQL Server 2000
CAST and CONVERT
The syntax for using the convert function is:
CONVERT ( data_type [ ( length ) ] , expression [ , style ] )
If you need the result as a varchar, you should go through
SELECT CONVERT(DATE, GETDATE()) --2014-03-26
SELECT CONVERT(VARCHAR(10), GETDATE(), 111) --2014/03/26
which is already mentioned above.
If you need result in date and time format, you should use any of the queries below
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
If you are using SQL Server 2012 or above versions,
Use Format() function.
There are already multiple answers and formatting types for SQL server.
But most of the methods are somewhat ambiguous and it would be difficult for you to remember the numbers for format type or functions with respect to Specific Date Format. That's why in next versions of SQL server there is better option.
FORMAT ( value, format [, culture ] )
Culture option is very useful, as you can specify date as per your viewers.
You have to remember d (for small patterns) and D (for long patterns).
1."d" - Short date pattern.
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" - Long date pattern.
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)
More examples 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日
If you want more formats, you can go to:
Standard Date and Time Format Strings
Custom Date and Time Format Strings
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
Using FLOOR() - just cut time part.
SELECT CAST(FLOOR(CAST(GETDATE() AS FLOAT)) AS DATETIME)
To obtain the result indicated, I use the following command.
SELECT CONVERT(DATETIME,CONVERT(DATE,GETDATE()))
I holpe it is useful.
IF you want to use CONVERT and get the same output as in the original question posed, that is, yyyy-mm-dd then use CONVERT(varchar(10),[SourceDate as dateTime],121) same code as the previous couple answers, but the code to convert to yyyy-mm-dd with dashes is 121.
If I can get on my soapbox for a second, this kind of formatting doesn't belong in the data tier, and that's why it wasn't possible without silly high-overhead 'tricks' until SQL Server 2008 when actual datepart data types are introduced. Making such conversions in the data tier is a huge waste of overhead on your DBMS, but more importantly, the second you do something like this, you have basically created in-memory orphaned data that I assume you will then return to a program. You can't put it back in to another 3NF+ column or compare it to anything typed without reverting, so all you've done is introduced points of failure and removed relational reference.
You should ALWAYS go ahead and return your dateTime data type to the calling program and in the PRESENTATION tier, make whatever adjustments are necessary. As soon as you go converting things before returning them to the caller, you are removing all hope of referential integrity from the application. This would prevent an UPDATE or DELETE operation, again, unless you do some sort of manual reversion, which again is exposing your data to human/code/gremlin error when there is no need.
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: The first two methods are essentially the same, and out perform the convert to varchar method.
If you are assigning the results to a column or variable, give it the DATE type, and the conversion is implicit.
DECLARE #Date DATE = GETDATE()
SELECT #Date --> 2017-05-03
Convert(nvarchar(10), getdate(), 101) ---> 5/12/14
Convert(nvarchar(12), getdate(), 101) ---> 5/12/2014
Date:
SELECT CONVERT(date, GETDATE())
SELECT CAST(GETDATE() as date)
Time:
SELECT CONVERT(time , GETDATE() , 114)
SELECT CAST(GETDATE() as time)
Syntax:
SELECT CONVERT (data_type(length)),Date, DateFormatCode)
Ex:
Select CONVERT(varchar,GETDATE(),1) as [MM/DD/YY]
Select CONVERT(varchar,GETDATE(),2) as [YY.MM.DD]
all dateformatcodes about Date:
DateFormatCode Format
1 [MM/DD/YY]
2 [YY.MM.DD]
3 [DD/MM/YY]
4 [DD.MM.YY]
5 [DD-MM-YY]
6 [DD MMM YY]
7 [MMM DD,YY]
10 [MM-DD-YY]
11 [YY/MM/DD]
12 [YYMMDD]
23 [yyyy-mm-dd]
101 [MM/DD/YYYY]
102 [YYYY.MM.DD]
103 [DD/MM/YYYY]
104 [DD/MM/YYYY]
105 [DD/MM/YYYY]
106 [DD MMM YYYY]
107 [MMM DD,YYYY]
110 [MM-DD-YYYY]
111 [YYYY/MM/DD]
112 [YYYYMMDD]
Simply you can do this way:
SELECT CONVERT(date, getdate())
SELECT DATEADD(dd, 0, DATEDIFF(dd, 0, #your_date))
SELECT DATEADD(dd, 0, DATEDIFF(dd, 0, GETDATE()))
Outputs as:
2008-09-22 00:00:00.000
Or simply do like this:
SELECT CONVERT (DATE, GETDATE()) 'Date Part Only'
Result:
Date Part Only
--------------
2013-07-14
In this case, date only, you we are gonna run this query:
SELECT CONVERT(VARCHAR(10), getdate(), 111);
I think this would work in your case:
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)
Okay, Though I'm bit late :), Here is the another solution.
SELECT CAST(FLOOR(CAST(GETDATE() AS FLOAT)) as DATETIME)
Result
2008-09-22 00:00:00.000
And if you are using SQL Server 2012 and higher then you can use FORMAT() function like this -
SELECT FORMAT(GETDATE(), 'yyyy-MM-dd')
Starting from SQL SERVER 2012, you can do this:
SELECT FORMAT(GETDATE(), 'yyyy-MM-dd 00:00:00.000')
Even using the ancient MSSQL Server 7.0, the code here (courtesy of this link) allowed me to get whatever date format I was looking for at the time:
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)
It produced this 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
why don't you use DATE_FORMAT( your_datetiem_column, '%d-%m-%Y' ) ?
EX: select DATE_FORMAT( some_datetime_column, '%d-%m-%Y' ) from table_name
you can change sequence of m,d and year by re-arranging '%d-%m-%Y' part
I know this is old, but I do not see where anyone stated it this way. From what I can tell, this is ANSI standard.
SELECT CAST(CURRENT_TIMESTAMP AS DATE)
It would be good if Microsoft could also support the ANSI standard CURRENT_DATE variable.
I favor the following which wasn't mentioned:
DATEFROMPARTS(DATEPART(yyyy, #mydatetime), DATEPART(mm, #mydatetime), DATEPART(dd, #mydatetime))
It also doesn't care about local or do a double convert -- although each 'datepart' probably does math. So it may be a little slower than the datediff method, but to me it is much more clear. Especially when I want to group by just the year and month (set the day to 1).