I have a managed object reference *event.
An Event has many Occurrences. An Occurrence has an attribute call date
I want to fetch all the occurrences of the event *event which has today's date. How should I write a NSPredicate on a FetchRequest.
Here is the construction of the predicate to filter out the event which occurs today.
NSDate *today = [NSDate date];
NSCalendar *gregorian = [[NSCalendar alloc]
initWithCalendarIdentifier:NSGregorianCalendar];
NSDateComponents *components =[gregorian components:(NSDayCalendarUnit|NSYearCalendarUnit|NSMonthCalendarUnit) fromDate:today];
[components setHour:0];
[components setMinute:0];
[components setSecond:0];
NSDate *todayMidnight=[gregorian dateFromComponents:components];
#define Hours_24 86400
NSDate *tomorrowMidnight=[NSDate dateWithTimeInterval:Hours_24 sinceDate:todayMidnight];
NSPredicate *predicate=[NSPredicate predicateWithFormat:#"occurance.date >= %# AND occurance.date< %#",todayMidnight,tomorrowMidnight];
[gregorian release];
Since the attribute of occurance is of NSDate datatype, it will have the time as well as the date. So, this predicate will filter out all occurances whose date falls between today midnight and tomorrow midnight. Another way(and better, in my opinion), would be to get the Occurances and then do the filtering.
Don't forget to setPropertiesToFetch: to occurance if you want only the occurance and not the event. This will return an NSDictionary.
You have to be aware, that there are two ways to get your Occurrence objects: You can traverse the relationship from the Event object (i.e. myEvent.occurences) or you can create a fetch request for all occurrences that have the event of interest in their inverse relationship, i.e. a predicate like [NSPredicate predicateWithFormat:#"event == %#", myEvent"].
There are fundamental differences to these two. A fetch request will always cause SQL to be executed and I/O to happen which is expensive. If you simply traverse the relationship, and you're in a situation where the Occurrence objects are already in memory, it will be very cheap to do (no SQL, no I/O). The fetch request on the other hand, will allow you to fault in all objects in one go, while traversing will only fault objects one at a time, so you'll end up doing multiple SQL + I/O events. Also, a fetch request allows you to limit the predicate even further. But in many cases, simply traversing might be the best case.
CoreData does a lot of heavy lifting for you, but at the end of the day, you still need to know about when to do SQL and I/O and how to prevent it.
I hope this helps.
Related
I have to determine the day of the week in an Objective C class.
Trying to use this method:
- (NSUInteger)ordinalityOfUnit:(NSCalendarUnit)smaller
inUnit:(NSCalendarUnit)larger
forDate:(NSDate *)date;
This is my code:
NSCalendar *gregorian = [[NSCalendar alloc] initWithCalendarIdentifier:NSCalendarIdentifierGregorian];
(int) [gregorian ordinalityOfUnit:NSCalendarUnitWeekday inUnit:NSCalendarUnitWeekday forDate:[NSDate date]];
It always returns -1, no matter what day it is. Even if I change the date, or loop through a whole week.
However, using this method, it works well:
- (NSDateComponents *)components:(NSCalendarUnit)unitFlags
fromDate:(NSDate *)date;
So far so good. The only problem is: this method is deprecated (first deprecated in iOS 8.0, so quite a long time ago).
Little bit afraid of using old deprecated methods for production. Is there a way of making the (not even very) new method work?
From the ordinalityOfUnit:inUnit:forDate: docs:
Returns, for a given absolute time, the ordinal number of a smaller calendar unit (such as a day) within a specified larger calendar unit (such as a week).
You have specified the same unit for the first two arguments, you need to specify day for the first and week for the second:
[gregorian ordinalityOfUnit:NSCalendarUnitDay inUnit:NSCalendarUnitWeekOfMonth forDate:[NSDate date]]
HTH
I've done research on this question and thought I found the answer which makes sense but it's not working so i'm not sure if I'm making a silly mistake. I want to query for data that is created in the past week, month, year,..etc. I looked at my data already uploaded to parse and to test it out, I wanted to query for the data from the past 5 days. For some reason, it finds 0 objects when there should be five objects created after August 8th. When I switched to lessThanOrEqualTo it found all 9 objects even though there's 4 objects created before August 8th. Any clarity on this. Thanks
NSDate *then=[NSDate dateWithTimeIntervalSinceNow:-7200];
PFQuery *query=[PFQuery queryWithClassName:#"urinationAmount"];
[query whereKey:#"user" equalTo:[PFUser currentUser]];
[query whereKey:#"createdAt" greaterThanOrEqualTo:then];
urinationDataArray=[query findObjects];
NSLog(#"Objects in Array:%i",urinationDataArray.count);
According to Date and Time Programming Guide, you shouldn't manually do calendar calculations.
Quote from the same document says:
NSDate provides the absolute scale and epoch for dates and times, which can then be rendered into a particular calendar for calendrical calculations or user display. To perform calendar calculations, you typically need to get the component elements of a date, such as the year, the month, and the day. You should use the provided methods for dealing with calendrical calculations because they take into account corner cases like daylight savings time starting or ending and leap years.
So five days ago should be something like this:
NSCalendar * currentCalendar = [NSCalendar currentCalendar];
NSDateComponents * dateComponents = [NSDateComponents new];
NSDate * now = [NSDate date];
[dateComponents setDay:-5];//five days ago
NSDate * fiveDaysAgo = [currentCalendar dateByAddingComponents:dateComponents toDate:now options:0];
You can check NSDateComponents Class Reference for further calendar units that you can use for your calculations.
The following code will not give you five days ago:
NSDate *then=[NSDate dateWithTimeIntervalSinceNow:-7200];
You should do:
NSDate *then=[NSDate dateWithTimeIntervalSinceNow:-1 * (86400 * 5)];
There are 86,400 seconds in a day.
I have a "time-tracking" app that allows a user to create an entry on whichever days a user desires but only one permitted per day. I store these entries into CoreData.
[rateObject setValue:[Day dateWithHour:currentDate forHour:12] forKey:#"date"];
Later, I retrieve these entries using the following code.
NSFetchRequest *request = [NSFetchRequest fetchRequestWithEntityName:#"Day"];
request.sortDescriptors = #[[NSSortDescriptor sortDescriptorWithKey:#"date" ascending:YES]];
request.predicate = [NSPredicate predicateWithFormat:#"whoWorked == %# && date => %# && date =< %#", whoWorked, [Day dateWithHour:fromDate forHour:0], [Day dateWithHour:toDate forHour:24]];
As you can see I placed the entry in the middle of the day (12 hours) and retrieved the dates from start of the first day (0 hours) and end of the last day (24 hours).
This is a hack which seems to work when I only shift timezones by a few hours or switch for Standard Time to Daylight Savings. It falls apart when I move from NA to Europe i.e. the entries in the old timezone appear on different days in the retrieval.
What I want to get to is an entry made on April 25, 2014 appears on April 25, 2014 no matter what timezone I am currently in.
I have looked at a number of sources to understand NSDate, NSDateComponents, NSCalendar etc but can't seem to land on a good understanding that will allow me to implement this correctly or cleanly. Any advice appreciated.
Here is my method for creating a date with a specific hour (in Day).
+ (NSDate *)dateWithHour:(NSDate *)date forHour:(int)hour {
// Create and initialize date component instance
NSDateComponents *dateComponents = [[NSCalendar currentCalendar] components:NSYearCalendarUnit | NSMonthCalendarUnit | NSDayCalendarUnit | NSHourCalendarUnit fromDate:date];
if (hour<0) hour = 0;
else if (hour>24) hour = 24;
[dateComponents setHour:hour];
// Create period dates
NSDate *newDate = [[NSCalendar currentCalendar] dateFromComponents:dateComponents];
return newDate;
}
The best to use time-zone and platform independent is the timestamp, which you can get from NSDate as well. With that you can easily do calculations with Time-intervals. If you want to have a specific date it is always related to the time zone of the user. Then you can convert the timestamp into a user-formatted date. Like mentioned by Zaph he might want to see the date where he currently is. Again with the timestamp this is always reliable.
If you want to calculate that an entry can be done only once per calendar day in the location where somebody is, then you can calculate with ˙NSCalendar˙ and ˙NSDateComponents˙ for example what day a timestamp represents and then from the beginning of that day calculate 24 hours up. Conversion back to a timestamp gives you a helpful range for check if something is within the same calendar day. The NSCalendar is the base for calculation even if you will probably use Gregorian most of the time. With the NSDateComponentsyou can what ever part you want from your Timestamp (e. g. only the day, the month, the year, etc.).
I am having some trouble calculating the number of seconds until a specified day of the week.
For example, calculate the number of seconds until Sunday from the current time in seconds.
The calculation must be dynamic so it is compatible for every Sunday.
Is there any way to accomplish this without specifying a specific date?
You need to use NSCalendar and NSDateComponents. See the code example below. Make sure to set the calendar to "gregorian" if you want the correct 7 day week for the US.
NSCalendar *gregorian = [[NSCalendar alloc] initWithCalendarIdentifier:NSGregorianCalendar];
unsigned unitFlags = NSWeekdayCalendarUnit | NSHourCalendarUnit | NSMinuteCalendarUnit | NSSecondCalendarUnit;
NSDate *date = [NSDate date];
NSDateComponents *comps = [gregorian components:unitFlags fromDate:date];
// Just a test line for your benefit.
NSLog(#"%li %li %li %li",(long)comps.weekday,(long)comps.hour, (long)comps.minute, (long)comps.second);
// I did this kinda fast - check it over good. Will need some sort of if statement in case the current day is Sunday (7)
NSInteger sec = (60 - comps.second) + (60 - comps.minute)*60 + (24 - comps.hour)*3600 + (6 - comps.weekday)*24*60*60;
NSLog(#"%li",sec);
You will have to modify this somewhat for your use. For instance if you want the day of the week to be a variable, etc. but this should get you on the right track.
Hope this helps. Good luck.
EDIT
See Duncan's remarks below for a better way to actually calculate the seconds.
The NSCalendar class has a whole bunch of methods for this sort of thing. Do a search on "Calendrical calculations" in Xcode for more information.
You'll need a Gregorian NSCalendar (or other type for other calendars like the Chinese, Arabic, Hebrew calendar) NSDates, and NSDateComponents objects.
Look at the method components:fromDate:toDate:options: in particular.
EDIT: That'll teach me to leave an answer unfinished and go do the dishes.
One difference from Dylan's post, though: I would take the current NSDate, convert it to components, then set the day-of-week to the desired future day of week, then convert back to an NSDate, and finally take the difference between the two dates using the NSDate method timeIntervalSinceDate.
I am trying to get the time difference between two NSDates.
NSDate *d1 = somedate;
NSDate *d2 = someOtherdate;
NSTimeInterval sec = [d2 timeIntervalSinceDate:d1];
How accurate is NSTimeInterval?
Does it take care of the variation in number of days in a month, for example if the number of days is 28,29,30 or 31? Also time zone difference?
How accurate is NSTimeInterval
On the platforms I know they have Cocoa, NSTimeInterval is typedeffed to double,
Does it take care of the variation in number of days in a month?
It's not NSTimeInterval that does that, it's a type. It's the various classes (NSDate, whatever) that take care of all these deviances. And they do it really well.
NSTimeInterval is in fact just a typedeffed double. Because NSDate represents a single point in time (independent of time zone, calendar, etc.), NSTimeInterval represents the number of seconds between the two dates (points in time).
NSTimeInterval is actually just a typedef for double.
NSDate encapsulates a time interval and provides an interface to interact with it.
If you want that date to be referenced to our actual calendar, you have to use the NSCalendar and NSDateComponents classes.
NSDateComponents *components = [[NSCalendar currentCalendar] components:NSDayCalendarUnit | NSMonthCalendarUnit | NSYearCalendarUnit fromDate:[NSDate date]];
Then you can get data out of the components object:
components.day
components.week
// etc
Assume the Mayan culture never went extinct. This right instant in time would be represented by the same NSDate object, but through a different NSCalendar (like a NSMayanCalendar) you would get a completely different representation of that date.
How accurate is NSTimeInterval?
It's accurate to milliseconds (if not more).
Does it take care of the variation in number of days in a month, for example if the number of days is 28,29,30 or 31?
Yes, the difference will be in seconds. NSDate deals with actual days in a month as well as leap years and daylight savings, etc.
Also time zone difference?
NSDate values are always stored in UTC so your NSDate objects are always in the same timezone. There is nothing to deal with for this.