Rounding DateTime in SQL - sql

I have DateTime data in a MS SQL database with the following format:
2020-05-07 22:35:00
I am trying to create a query that only captures data from the last 24 hours of operations. However, our operations KPIs are measured from 6AM-6AM. I would like to round the date based on time. Anything before 6AM will be counted as the day before.
2020-05-07 05:45:00 -> 2020-05-06 (Before 6AM)
2020-05-07 06:30:00 -> 2020-05-07 (After 6AM)
So far I have been successful in pulling the previous days activity, but am struggling to shift the timeframe to round down anything before 6AM
SELECT
end_date
FROM data sint
WHERE sint.end_date >= dateadd(day,datediff(day,1,GETDATE()),0)
AND sint.end_date < dateadd(day,datediff(day,0,GETDATE()),0)


You can add six hours to the current date (without the time) for the comparison:
where int.end_date < dateadd(hour, 6, convert(datetime, convert(date, getdate()))) and
int.end_date >= dateadd(hour, 6 - 24, convert(datetime, convert(date, getdate())))
Note that the conversion to date removes the time component.


first get the time part. Compare the time part with 6AM and run your expression.
In below code the time part is compared with the date '1900-01-01 06:00:00' which is 6AM in default date format.
select
case when cast(date as time(0)) < '1900-01-01 06:00:00'
then cast(date - 1 as date)
else cast(date as date)
end as newdate
from temp_date;


I would do the same as Gordon only the opposite side.
I would subtract 6 hours from end_date and then compare.
where convert(date, dateadd(hour, -6, int.end_date)) = convert(date, getdate())
Though this method might not work well if you're actually using getdate(). It will return nothing if it is ran between midnight and 6 am (unless you have future dates).

Related

SQL query to start from hour 12:00 am

I have a date column like this 7/24/2017 and when I write the below where clause I get results from hour 7/24/2017 1:00:00.000 AM. I need to get this from 7/24/2017 12:00:00.000 AM. How should this where clause me modified. Please check the following code
Date>= DATEADD(day, -1, convert(date, GETDATE())) and
Date< DATEADD(day, +0, convert(date, GETDATE()))

There doesn't appear to be anything wrong with your code. Are you certain your data contains any times before 1am? Are you certain you appreciate how your SQLServer will format those times/represent them to you?
See this SQLFIDDLE: http://sqlfiddle.com/#!6/047cc/11
Optimisations: you don't need to dateadd a value of 0. You can also subtract 1.0 from a date to get the day earlier and it's a bit less wordy than DATEADD. It works because internally dates are represented as floating point numbers of the number of days since a point in time:
[Date] >= convert(date, GETDATE() -1.0) and
[Date] < convert(date, GETDATE())

SQL Find if two UTC Dates are in the same calendar day

I have a table with a DateTime column, this column contains a DateTime in UTC which in local time is always time 00:00:00.000, this is because I only care about Date part, not time but I need to store the Date in UTC.In my local time, the UTC offset is -6 hours, so, all my dates are stored with a time equals to 6, for example, '2017-01-03 06:00:00.000' . The problem is that when I try to compare this:
SELECT (CASE WHEN (CONVERT(DATE, '2017-01-03 06:00:00.000') = CONVERT(DATE, GETUTCDATE())) THEN 1 ELSE 0 END) AS [IsEqual]
If the result of GETUTCDATE is another day but the hour is smaller than 6, for example, '2017-01-04 02:00:00.000', this date in local time still belong to January 3, but the above comparison returns false because is checking if 2017-01-03 = 2017-01-04.
How can I find id this two UTC dates are on the same calendar day?

If your local time is always 6 hours from UTC (meaning no Daylight saving time), you should subtract 6 hours from GETUTCDATE() and then compare to your local time:
SELECT CASE WHEN
CONVERT(DATE, '2017-01-03 06:00:00.000') =
CONVERT(DATE, DATEADD(HOUR, -6, GETUTCDATE())) THEN
1
ELSE
0
END AS [IsEqual]

Query previous day with GETDATE()-1 and a time period from/to

I want to get total counts from SuperScottTable1 from the previous day and narrow to a time frame (From-To). The below works fine until I add
AND (time > '08:00:00.000' AND time < '22:00:00.000')
It does not error, just returns null.
Is this possible to do?
SELECT
SUM(COALESCE(confirmedCount, 0))
FROM
SuperScottTable1
WHERE
superLaneID = '90099'
AND time >= GETDATE()-1
AND (time > '08:00:00.000' AND time < '22:00:00.000')

You can do some CAST/CONVERT shenanigans to generate a starting and stoping DATETIME value which you can then compare to your time column. If the time column is indexed then this will allow the server to do a simple range search on the index to find matches.
WHERE
superLaneID = '90099'
AND time > CAST(CONVERT(VARCHAR(20), GETDATE()-1, 112) + ' 08:00:00' AS DATETIME)
AND time < CAST(CONVERT(VARCHAR(20), GETDATE()-1, 112) + ' 22:00:00' AS DATETIME)

Presumably, time is stored as a datetime. You seem to be using SQL Server, so you can extract the hour and use that:
WHERE superLaneID = '90099' AND
time >= GETDATE()-1 AND
datepart(hour, time) >= 8 AND
datepart(hour, time) < 22
EDIT: To get the "other" hours:
WHERE superLaneID = '90099' AND
time >= GETDATE()-1 AND
(datepart(hour, time) < 8 or
datepart(hour, time) >= 22
)

GETDATE() in SQL Server returns the system date and time to arrive at the current day (i.e. date at time 00:00:00.0000000) you can use either of these:
cast(getdate() as date) -- available from SQL 2008 onward
dateadd(day, datediff(day,0, getdate() ), 0) -- any SQL Server version
Using these to establish the current date, then add (8-24) hours and or (22-24) hours to establish the boundaries of yesterday e.g.
WHERE superLaneID = '90099'
AND time >= dateadd(hour,(8-24),cast(getdate() as date))
AND time < dateadd(hour,(22-24),cast(getdate() as date))
Avoid using non-sargable predicates (such as using a function) that require you to alter each row of data to compare to a fixed value. ref this prior answer
Btw: This method discussed here would work for a time range that spans midnight.

SQL Date only in Where clause [duplicate]

If I have a date value like 2010-03-01 17:34:12.018
What is the most efficient way to turn this into 2010-03-01 00:00:00.000?
As a secondary question, what is the best way to emulate Oracle's TRUNC function, which will allow you to truncate at Year, Quarter, Month, Week, Day, Hour, Minute, and Second boundaries?

To round to the nearest whole day, there are three approaches in wide use. The first one uses datediff to find the number of days since the 0 datetime. The 0 datetime corresponds to the 1st of January, 1900. By adding the day difference to the start date, you've rounded to a whole day;
select dateadd(d, 0, datediff(d, 0, getdate()))
The second method is text based: it truncates the text description with varchar(10), leaving only the date part:
select convert(varchar(10),getdate(),111)
The third method uses the fact that a datetime is really a floating point representing the number of days since 1900. So by rounding it to a whole number, for example using floor, you get the start of the day:
select cast(floor(cast(getdate() as float)) as datetime)
To answer your second question, the start of the week is trickier. One way is to subtract the day-of-the-week:
select dateadd(dd, 1 - datepart(dw, getdate()), getdate())
This returns a time part too, so you'd have to combine it with one of the time-stripping methods to get to the first date. For example, with #start_of_day as a variable for readability:
declare #start_of_day datetime
set #start_of_day = cast(floor(cast(getdate() as float)) as datetime)
select dateadd(dd, 1 - datepart(dw, #start_of_day), #start_of_day)
The start of the year, month, hour and minute still work with the "difference since 1900" approach:
select dateadd(yy, datediff(yy, 0, getdate()), 0)
select dateadd(m, datediff(m, 0, getdate()), 0)
select dateadd(hh, datediff(hh, 0, getdate()), 0)
select dateadd(mi, datediff(mi, 0, getdate()), 0)
Rounding by second requires a different approach, since the number of seconds since 0 gives an overflow. One way around that is using the start of the day, instead of 1900, as a reference date:
declare #start_of_day datetime
set #start_of_day = cast(floor(cast(getdate() as float)) as datetime)
select dateadd(s, datediff(s, #start_of_day, getdate()), #start_of_day)
To round by 5 minutes, adjust the minute rounding method. Take the quotient of the minute difference, for example using /5*5:
select dateadd(mi, datediff(mi,0,getdate())/5*5, 0)
This works for quarters and half hours as well.

If you are using SQL Server 2008+, you can use the Date datatype like this:
select cast(getdate() as date)
If you still need your value to be a DateTime datatype, you can do this:
select cast(cast(getdate() as date) as datetime)
A method that should work on all versions of SQL Server is:
select cast(floor(cast(getdate() as float)) as datetime)

Try:
SELECT DATEADD(dd, DATEDIFF(dd, 0, GETDATE()), 0)
UPDATE: answer on the second question:
for years you could use a little bit modified version of my answer:
SELECT DATEADD(yy, DATEDIFF(yy, 0, GETDATE()), 0)
for quarter:
SELECT DATEADD(qq, DATEDIFF(qq, 0, GETDATE()), 0)
and so on.
I checked, up to minutes - it's OK. But on seconds I've got an overflow message:
Difference of two datetime columns
caused overflow at runtime.
One more update: take a look to the following answer to the same question

This is late, but will produce the exact results requested in the post. I also feel it is much more intuitive than using dateadd, but that is my preference.
declare #SomeDate datetime = '2010-03-01 17:34:12.018'
SELECT
DATEFROMPARTS(
YEAR(#SomeDate)
,MONTH(#SomeDate)
,'01'
) AS CUR_DATE_FROM_PARTS
,DATETIMEFROMPARTS(
YEAR(#SomeDate)
,MONTH(#SomeDate)
,'01' --DAY(#SomeDate)
,'00' --DATEPART(HOUR,#SomeDate)
,'00' --DATEPART(MINUTE,#SomeDate)
,'00' --DATEPART(SECOND,#SomeDate)
,'00' --DATEPART(MILLISECOND,#SomeDate)
) AS CUR_DATETIME_FROM_PARTS
,#SomeDate AS CUR_DATETIME
,YEAR(#SomeDate) AS CUR_YEAR
,MONTH(#SomeDate) AS CUR_MONTH
,DAY(#SomeDate) AS CUR_DAY
,DATEPART(HOUR,#SomeDate) AS CUR_HOUR
,DATEPART(MINUTE,#SomeDate) AS CUR_MINUTE
,DATEPART(SECOND,#SomeDate) AS CUR_SECOND
,DATEPART(MILLISECOND,#SomeDate) AS CUR_MILLISECOND
FROM Your_Table
Truncated Date: 2010-03-01
Truncated DateTime: 2010-03-01 00:00:00.000
DateTime: 2010-03-01 17:34:12.017

Not sure if this is the most efficient, but I like the simplicity in using the following where #SomeDate is your field.
Concat(Year(#SomeDate), '-', Month(#SomeDate), '-', '01')

If you want to truncate a date to the start of the week in a way that is independent of SET DATEFIRST you can:
--change a date backwards to nearest Monday
DATEADD(DAY, (DATEPART(dw, '2001-01-01') - DATEPART(dw, YOUR_COLUMN)-7)%7, YOUR_COLUMN)
Breaking this down:
DATEPART(dw, '2001-01-01') - DATEPART(dw, YOUR_COLUMN): the dw of a known Monday (2001-01-01 was a Monday) minus the dw of your date, effectively giving the "number of days difference between your date and Monday" or "how many days back do we have to scroll your date to make it into Monday"
( ... -7)%7 - we subtract 7 from it and modulo the result by 7.
We do this because if e.g. DATEFIRST is 7 (Sunday), and your date column is Sunday then your dw is 1, and your known Monday is 2.
This means the result of the dw_for_known_monday - dw_for_your_date is +1 rather than -6
This would then mean that DATEADD will roll your date forwards to the following Monday rather than backwards to the previous Monday
If we subtract 7 off it then the result would definitely be negative, but then we wouldn't want your Mondays (which are 0 days different from the known Monday) to end up doing a DATEADD of -7, so we modulo the result by 7.
This turns any problematic -7 into 0, which means your DATEADD will only ever have a "number of days" argument between -6 and 0
DATEADD(DAY, (DATEPART(dw, '2001-01-01') - DATEPART(dw, YOUR_COLUMN)-7)%7, YOUR_COLUMN) - we then DATEADD the (negative) number of days from the above step
If you want to roll your date backwards to e.g. a Sunday, change the date 2001-01-01 to a date that is a known Sunday (like 2000-12-31), etc

Break this simple SQL/HQL Query down - DATEADD, DATEDIFF?

select * from table
where Date BETWEEN DATEADD(dd, DATEDIFF(dd, 84, GETDATE()),0)
and DATEADD(dd, DATEDIFF(dd, 77, GETDATE()),0)
Can someone please explain what this query is doing? Specifically, what is the function of DATEADD and DATEDIFF in this query?

They're trying to get the membership renewals between 84 and 77 days ago, stripping out the time.
GETDATE() returns the datetime but the user isn't interested in the time.
DATEDIFF(dd, 84, GETDATE()) gets the number of days between the current date and the 84th day after Jan 1, 1900.
DATEADD(dd, # days from above, 0) adds those number of days to Jan 1, 1900.
The net is you get 84 days ago at 00:00:00 AM.
If you just did DATEADD(dd, -84, GETDATE()) then you'd have 84 days ago + the current time.
Other ways to do the same thing are to cast the datetime to a date (assuming MS SQL Server).
.. CAST((GETDATE() - 84) AS DATE)
.. CAST(DATEADD(day, -84, GETDATE()) as DATE)

Your expression is using SQL Server syntax to convert a datetime to a date (that is, to remove the date component. The format is quite arcane, because the expression is doing getdate() - 84 as an integer and then adding this to the 0 date. The elimination of the "time" component occurs because the datediff() returns an integer.
I don't think this will work in HQL. For instance, the dd should be 'dd' and HQL has a different method of getting the current date.
And, in more recent versions of SQL Server, you can just do cast(getdate() - 84 as date).