TweetFollow Us on Twitter

Introduction to Core Data, Part III

Volume Number: 21 (2005)
Issue Number: 11
Column Tag: Programming

Introduction to Core Data, Part III

Fetch, Clarus, Fetch

by Jeff LaMarche

In the previous two Core Data articles, we discussed how to create a data model and how to create, delete, and edit data instances both directly from the user interface and programmatically. Those two articles covered most of what you'll need to do with your application data models. Most. But not all. There's one important area that those articles didn't touch on.

In the prior articles, all instances of data that we worked with were ones that we created, or else were ones that the user took some action upon, so we never had to worry about what piece of data we were going to work with. There are times, however, when you will need to retrieve a piece of data from your application's context, but instead of knowing, for example, that the user clicked on the row that corresponds to a specific data instance, you'll know only some criteria about that data. For example, you might need to find a book instance based on its title or, perhaps, to find all the books by a particular author or publisher, or to find all the books published in a given year.

Now, certainly, you could create an NSArrayController in Interface Builder to represent all the instances of a particular entity type and then manually loop through the items it manages to look for the instances that meet your criteria, but that would be inefficient and involve a lot of unnecessary work. You're much better off using the tools Apple gives you for this purpose.

Fetch Requests

The mechanism that you use to retrieve data programmatically from your application's or document's context is called (appropriately) a Fetch Request, and is represented by the Cocoa class NSFetchRequest. To use this class, you instantiate a request object then provide it with the criteria that describes the object or objects that you want to retrieve. After that, you execute the fetch request, and it returns to you an array of NSManagedObjects that match those criteria. Fetch requests exist in both Enterprise Objects Framework (EOF) and in Core Data, and function very similarly, so if you've used EOF fetch requests or another object-relational mapping tool like Hibernate or Cayenne, this process will seem familiar to you.

Enterprise Objects has a very handy class of utility methods called EOUtilities which encapsulates a lot of commonly used functionality into public static methods (Java's equivalent to Objective-C's class methods) that can be called from anywhere. Core data has no comparable class, despite using a nearly identical mechanism for retrieving data.

So, this month, instead of building a whole new application, we're going to implement a class similar to EOUtilities (but much less extensive) called MTCDUtilities (that stands for MacTech Core Data Utilities, if you were wondering). The methods we are going to implement will make it easier to retrieve data from your context and also, in the process, will show you how to find and retrieve data from your application's context based on criteria. MTCDUtilities will have four class methods (much less than EOUtilities) and no instance variables, so you will never instantiate an MTCDUtilities object, but rather simply call methods on the class object.

The complete class we're building is available on the MacTech FTP site, with complete HeaderDoc documentation. Before we learn how to specify criteria for retrieving data, let's take a quick look at retrieving data without criteria. When you do not specify any criteria, a fetch request retrieves all the existing instances of a given entity. The first of our four convenience methods does exactly that. Before we write it, let's create our class' header, with declarations of the methods we're going to be writing.

MTCDUtilities.h

This is the header for MTCDUtilities. There are no instance variables, just four class method declarations. To save space, I have not included the HeaderDoc comments.

#import <Cocoa/Cocoa.h>
#define MTTooManyEntitiesReturnedException 
   @"Too many entities returned"
#define MTCoreDataExeption @"Core Data exception"
@interface MTCDUtilities : NSObject 
{
}
+(NSArray *)objectsForEntityNamed:(NSString *)name
   inContext:(NSManagedObjectContext *)context;
+(NSArray *)objectsForEntityNamed:(NSString *)name 
   matchingKey:(NSString *)key
   andValue:(id)value 
   inContext:(NSManagedObjectContext *)context;
+(NSManagedObject *)objectForEntityNamed:(NSString *)name 
   matchingKey:(NSString *)key andValue:(id)value 
   inContext:(NSManagedObjectContext *)context;
+(NSArray *)objectsForEntityNamed:(NSString *)name
   matchingKeysAndValues:(NSDictionary *)keyValues 
   usingOR:(BOOL)useOR
   inContext:(NSManagedObjectContext *)context;
@end

For now, don't worry about any of the methods except for objectsForEntityNamed:inContext:, which we'll be writing first. We'll write the rest after we look at how to specify criteria.

MTCDUtilities.m / objectsForEntityNamed:inContext:

This method returns all instances of a given entity.

+(NSArray *)objectsForEntityNamed:(NSString *)name 
   inContext:(NSManagedObjectContext *)context
{

   // We have to tell the Fetch Request which entity instances to retrieve. We do
   // that using an NSEntityDescription based on the parameter name.
   NSEntityDescription *entity = [NSEntityDescription 
      entityForName:name inManagedObjectContext:context];

   // Next, we declare an NSFetchRequest, and give it the entity description
   NSFetchRequest *req = [[NSFetchRequest alloc] init];	[req setEntity:entity];

   // Before executing the fetch request, we declare an NSError
   // which is used to find out about any problems encountered
   // executing the request

   NSError *error = nil;

   // We next supply it (by reference) when we execute the request

 NSArray *array = [context executeFetchRequest:req 
      error:&error];

   // A nil array tells us something went wrong

if (array == nil)
   {
      // We instantiate an exception using the error description from
      // NSError, then raise the exception, which stops execution

NSException *exception = [NSException 
         exceptionWithName:MTCoreDataExeption 
         reason:[error localizedDescription] 
         userInfo:nil];

      // Since execution will stop when we raise the exception, we
      // need to release any memory before we do so. 

      [req release];
      [exception raise];
   }

   // We allocated it, we have to release it

[req release];

   // Return the result set returned from executing the fetch request

   return array;
}

Now, any time we want to retrieve all the instances of a given entity, we can simply do something like:

NSArray *array = [MTCDUtilities 
   objectsForEntityNamed:@"Book" 
   inContext:context];

Predicates and Format Strings

That's all well and good, but when you want execute a fetch request to retrieve less than all of the instances, you're going to need to tell the request exactly which data instances you want to retrieve. The way that criteria are specified in Core Data is by way of something called a predicate, which is represented by the class NSPredicate and its subclasses.

An example of a predicate, in plain English, is "Name is 'Joe'" or "Age is less than 21". Predicates can be more complex, however, such as "Name is 'Joe' or 'Fred' or begins with the letter "I" and age is less than 21 or parent has given permission." The latter is an example of a compound predicate. Predicates are completely distinct from entities and fetch requests. You can create one predicate, say, "Name is 'Joe'" and use it to retrieve all the People entities with a name of Joe and then turn around and use the same predicate to retrieve all the Dog entities named Joe. Predicates don't know or care one whit about the entities they are being used to retrieve.

Predicates can be assembled programmatically by creating expressions, arguments, and substitution variables and compounding them into predicates. You will rarely, if ever, do this, however, because Apple has provided a much nicer mechanism for creating predicates: the Format String.

You've used format strings in Cocoa before. NSString has a similar mechanism that allows you to assemble multiple strings, raw datatypes, and Objective-C object instances into a single NSString using stringWithFormat:. The format strings used by NSPredicate are similar, but not exactly the same, as those used by NSString. Both types of format strings use substitution variables, but NSPredicate adds a bit of functionality. Because the format strings used to specify criteria has its roots in SQL (Structured Query Language--the language used to retrieve data from databases), internally it is fairly picky about certain language constructs. For example, if you're comparing a string attribute to a constant value, the constant value must be contained within single quotes.

For the most part, however, if you use format strings to create your predicates, you won't have to worry about such things. When you use NSPredicate's predicateWithFormat: method, it will automatically do the right thing based on the type of object you pass in as a substitution variable. If you give it a string, it will add the appropriate quotes. If you give it a date, it will translate it into the appropriate date string for comparison. If you give it an NSNumber, it will leave the quotes off..

Despite the fact that it is very savvy about dealing with substitution variables, NSPredicate is still pickier about format strings than is NSString. There are a limited number of operators that you can use to create a valid predicate. You can use all the major C and SQL operators that you are accustomed to, such as == or = for an equals comparison, > for greater than, < for less-than, != or <> for not equal to, >= for greater than or equal to, and <= for less than or equal to. You can also use AND (or &&), OR (or ||), or NOT (or !) to compound phrases in your format string.

Here are a few examples of creating a predicate using a format string:

NSPredicate *pred1 = 
   [NSPredicate predicateWithFormat:@"age <= 21"];
NSPredicate *pred2 = [NSPredicate predicateWithFormat:
   @"name == %@ OR name == %@", @"Mary", @"Joe"];

Note that in the first example, I'm using a constant value (21) right in the format string. You can do this with numbers safely, but not with strings. You could not, for example, do this:

NSPredicate *pred = [NSPredicate 
   predicateWithFormat:@"name == Bob"];

Why? Well, remember what I said earlier about NSPredicate being picky internally about things like quotes around strings? If you don't use substitution variables, you're responsible for making sure that your constant matches NSPredicate's internal format requirements. Since attribute names cannot be made up of solely numbers, there's no chance of confusion between a number constant and an attribute name or reserved keyword. The same isn't true for string constants.

In general, it's safer to always use substitution variables, even when you're using a constant value. If you're curious, the following code will work (notice the single quotes), though I don't recommend you make a habit of creating predicates this way:

NSPredicate *pred = [NSPredicate 
   predicateWithFormat:@"name == 'Bob'"];

In addition to the operators mentioned above, there are also a slew of operators specifically for comparing string attributes, such as BEGINSWITH, CONTAINS, ENDSWITH, LIKE, and MATCHES. The first three are self-explanatory. The LIKE operator will be familiar to anyone who has worked with SQL: It functions identically to == except that it allows the use of two wildcard characters. When using LIKE, the character * works as an unbounded wildcard, so for example, 'w*t' would match 'wet', 'woot', and 'well I'd like to see you again if you permit it'. The ? character, on the other hand, is a bounded, single character wildcard, so 'w?t' would match 'wet' and 'wat' but not 'woot'.

MATCHES is similar to LIKE, except that it allows the use of full regular expressions rather than the more simplistic wildcards supported by LIKE. Regular expressions are beyond the scope of this article, so we won't be discussing MATCHES at all, but I will reiterate my comment from the first Core Data article that taking the time to learn regular expressions is well worth your time as a Cocoa programmer or OS X power user.

String operators have two optional modifiers (c and d) that can be specified in square brackets immediately following the operator. These can be used to specify (respectively) case sensitivity and diacritical sensitivity. By default, string comparisons in Core Data are both case-insensitive and diacritical-insensitive, meaning that if you create a predicate 'name CONTAINS bob', you would get back data instances where the attribute name equals 'Bob', 'bob', 'BOB', or even 'BOB'. Here is an example of creating a predicate string that is case and diacritical sensitive or, in other words, here's how you get 'Bob' without getting his German cousin 'BOB' or his Swedish cousin 'Bob':

NSPredicate *pred = [NSPredicate predicateWithFormat:
   @"name LIKE[cd] %@", @"Bob"];

There are a few more operators available to you, but the ones I've mentioned will make up the vast, vast majority of what you'll use; you can feel free to investigate the others in Apple's Predicate documentation.

There's one more difference between the format strings used by NSString and those used by NSPredicate that needs to be mentioned: NSPredicate supports only two substitution variables, one of which is not supported by NSString. Both NSString and NSPredicate allow the %@ variable for substituting Objective-C objects into the string. NSPredicate does not support the fprint-style format variables such as %d, %f, or %s. It does however, add a new substitution variable not used by NSString: %K.

The %K substitution variable is used for key paths and attribute names. If the name of the attribute you want to compare might change, you cannot use %@ to do so. So, for example, this won't work:

NSPredicate *pred = [NSPredicate predicateWithFormat:
   @"%@ == %@", @"name", @"Joe"];

The reason that this doesn't work is that NSPredicate recognizes the %@ operator only for substituting values not for substituting keys. When you are specifying an attribute name or key path, you have to use %K instead of %@. To correct that previous code example, we simply substitute %K for the first %@ like so:

NSPredicate *pred = [NSPredicate predicateWithFormat:
   @"%K == %@", @"name", @"Joe"];

Fetching with Predicates

Now that you've been introduced to predicates, we're ready to write the rest of our Core Data utility functions. First, let's write a utility method for a very common fetch: fetching all entities where one particular attribute has a particular value. Although NSPredicate allows very complex queries, you're likely to find that the bulk of the queries you actually use in your applications are relatively simple, and this method will make life easier in those situations.

MTCDUtilities.m - objects objectsForEntityNamed:matchingKey:andValue:inContext

+(NSArray *) objectsForEntityNamed:(NSString *)name 
   matchingKey:(NSString *)key 
   andValue:(id)value 
   inContext:(NSManagedObjectContext *)context
{
   // Since NSString and NSPredicate use different format strings,
   // we use a two-step process to create our format string here

   NSString *predString = [NSString stringWithFormat:
      @"%@ == %%@", key];
   NSPredicate *pred = [NSPredicate 
      predicateWithFormat:predString, value];

   // We still need an entity description, of course

   NSEntityDescription *entity = [NSEntityDescription 
      entityForName:name inManagedObjectContext:context];

   // And, of course, a fetch request. This time we give it both the entity
   // description and the predicate we've just created.

   NSFetchRequest *req = [[NSFetchRequest alloc] init];
   [req setEntity:entity];	
   [req setPredicate:pred];

   // We declare an NSError and handle errors by raising an exception,
   // just like in the previous method
	
NSError *error = nil;
   NSArray *array = [context executeFetchRequest:req
      error:&error];    
   if (array == nil)
   {
      NSException *exception = [NSException 
         exceptionWithName:MTCoreDataExeption 
         reason:[error localizedDescription] 
         userInfo:nil];
      [exception raise];
   }

   // Now, release the fetch request and return the array

   [req release];
   return array;
}

Very handy. Now, we have a convenience method for retrieving object instances matching a single key/value pair, like so:

NSArray *results = [MTCDUtilities objectsForEntityNamed:
   @"person" matchingKey:@"lastName" 
   andValue:@"Smith" 
   inContext:context];

More importantly, you now know the basics of creating a fetch request using a predicate, so should be able to craft more complex fetch requests for situations where this method is inadequate.

Now, in practice, you'll likely find yourself using the method above a lot of times with unique identifiers. In those situations, you know you'll only retrieve a single object, but yet you'll still get back an array. For situations where you know there will only be a single matching object, perhaps another convenience method is in order.

MTCDUtilities.m - objectForEntityNamed:matchingKey:andValue:inContext:

This method returns a single object matching a single key/value pair. If more than one object is actually returned, an exception is thrown.

+(NSManagedObject *)objectForEntityNamed:(NSString *)name 
   matchingKey:(NSString *)key 
   andValue:(id)value 
   inContext:(NSManagedObjectContext *)context
{

   // We call the previous method, then return the object at index 0. We 
   // declare no exception handler, so an exception encountered in this call
   // will stop execution of this method and throw up to the code 
   // from where it was called.

   NSArray *array = [MTCDUtilities 
      objectsForEntityNamed:name 
      matchingKey:key andValue:value inContext:context];

   // If there are more than one objects in the array, throw an exception

   if ([array count] > 1)
   {
      NSException *exception = [NSException 
         exceptionWithName:MTTooManyEntitiesReturnedException 
         reason:@"Too many instances retrieved for criteria" 
         userInfo:nil];	
      [exception raise];
   }
   // If there are no objects, just return nil

if ([array count] == 0)
      return nil;
		
   // Return the object at index 0
	
return (NSManagedObject *)[array objectAtIndex:0];
}

Now you'll be able to pull back a specific item with aplomb:

NSManagedObject *item = [MTCDUtilities 
   objectsForEntityNamed:@"book" matchingKey:@"id" 
   andValue:[NSNumber numberWithInt:192] inContext:context];

Notice that I passed an NSNumber instead of a string? That's not only acceptable, it's the correct thing to do when the attribute you're using is a numeric value, just as you would pass an NSDate if you were comparing a date attribute.

Compounding Predicates

But wait! There's more! If you order in the next ten minutes, I'll throw in this free set of Ginsu(TM) knives. Okay, not really, but I will throw in one more handy method. You won't always be able to get away with using queries based on a single key-value pair. Sometimes you'll need, for example, to pull back a person based on a first AND a last name, or pull back all entities of one type OR another type. These situations are accomplished with a specialized subclass of NSPredicate called NSCompoundPredicate.

Given any two or more existing NSPredicates, you can create a compound predicate using the logical operators AND, OR, or NOT. You simply create an array with all the predicates you want to join, and pass them into one of NSCompoundPredicate's convenience class methods, like so:

NSArray *preds = [NSArray arrayWithObjects:
   pred1,pred2, nil];
NSPredicate *notPred = [NSCompoundPredicate 
   notPredicateWithSubpredicates:preds];
NSPredicate *andPred = [NSCompoundPredicate 
   andPredicateWithSubpredicates:preds];
NSPredicate *orPred = [NSCompoundPredicate 
   orPredicateWithSubpredicates:preds];

You can even compound existing compound predicates, which we'll do in this last method.

MTCDUtilities.m - objectsForEntityNamed:matchingKeysAndValues:usingOR:inContext

Finds all instances of a given entity based on an NSDictionary of key/value pairs. The key-value pairs will be turned into equality predicates and compounded using either OR or AND depending on the value of useOR.

+(NSArray *)objectsForEntityNamed:(NSString *)name 
   matchingKeysAndValues:(NSDictionary *)keyValues 
   usingOR:(BOOL)useOR 
   inContext:(NSManagedObjectContext *)context
{
   // We'll retrieve an enumerator of all the keys in the dictionary
   NSEnumerator *e = [keyValues keyEnumerator];

   // Declare the predicate outside of the enumerator loop
	
NSPredicate *pred = nil;

   // Declare a string to hold the current key while looping

    NSString *key;
    
   while (key = [e nextObject]) 
   {
      // Declare a format string for creating the current subpredicate

      NSString *predString = 
         [NSString stringWithFormat:@"%@ == %%@",  key];

      // First time through, pred is nil and shouldn't be compounded with anything

      if (pred == nil)
         pred = [NSPredicate predicateWithFormat:predString, 
            [keyValues objectForKey:key]];
      else
      {

         // if pred is not nil, then create a compound based on the new
         // subpredicate tempPred and the existing predicate pred

         NSPredicate *tempPred = [NSPredicate 
            predicateWithFormat:predString, 
            [keyValues objectForKey:key]];
         NSArray *array = [NSArray arrayWithObjects:tempPred, 
            pred, nil];
            if (useOR)
            pred = [NSCompoundPredicate 
               orPredicateWithSubpredicates:array];
      else
            pred = [NSCompoundPredicate a
               ndPredicateWithSubpredicates:array]; 
      }
   }

   // Everything from here down should look familiar.

   NSEntityDescription *entity = [NSEntityDescription 
      entityForName:name inManagedObjectContext:context];
  NSFetchRequest *req = [[NSFetchRequest alloc] init];
   [req setEntity:entity];	
   [req setPredicate:pred];
   NSError *error = nil;
   NSArray *array = [context executeFetchRequest:req 
      error:&error];    
   if (array == nil)
   {
      NSException *exception = [NSException 
         exceptionWithName:MTCoreDataExeption 
         reason:[error localizedDescription] 
         userInfo:nil];
      [exception raise];
   }
   [req release];
   return array;
}

To use this last method, simply pack a dictionary with the attributes as the keys and the values to compare them to as the values, like so:

   NSDictionary *dict = [NSDictionary 
      dictionaryWithObjectsAndKeys:@"BookCo", @"publisher", 
      [NSNumber numberWithInt:482769], @"salesRank", nil];
   NSArray *array = [MTCDUtilities objectsForEntityNamed:
      @"Book" matchingKeysAndValues:dict usingOR:YES 
      inContext:[self managedObjectContext]];

Conclusion

This article gives you the last missing major building block for creating Core Data applications. Between this article and its two predecessors, you should now feel comfortable creating a Core Data data model, hooking it into your interface, interacting with it programmatically, and finding data within your application's context.

Core Data may seem a little intimidating at first, especially if you've never worked with an object-relational mapping tool such as EOF or Cayenne before. Hopefully these three articles have given you enough information to realize that Core Data really isn't scary at all, but that it can give you a frightening increases in your productivity.


Jeff LaMarche wrote his first line of code in Applesoft Basic on a Bell & Howell Apple //e in 1980 and he's owned at least one Apple computer at all times since. Though he currently makes his living consulting in the Mac-unfriendly world of "Enterprise" software, his Macs remain his first and greatest computer love. You can reach him at jeff_lamarche@mac.com.

 

Community Search:
MacTech Search:

Software Updates via MacUpdate

Alfred 4.2 - Quick launcher for apps and...
Alfred is an award-winning productivity application for OS X. Alfred saves you time when you search for files online or on your Mac. Be more productive with hotkeys, keywords, and file actions at... Read more
MenuMeters 2.0.8 - CPU, memory, disk, an...
MenuMeters is a set of CPU, memory, disk, and network monitoring tools for Mac OS X. Although there are numerous other programs which do the same thing, none had quite the feature set I was looking... Read more
ClipGrab 3.8.15 - Download videos from Y...
ClipGrab is a free downloader and converter for YouTube, Vimeo, Facebook and many other online video sites. It converts downloaded videos to MPEG4, MP3 or other formats in just one easy step Version... Read more
Malwarebytes 4.6.11.3824 - Adware remova...
Malwarebytes (was AdwareMedic) helps you get your Mac experience back. Malwarebytes scans for and removes code that degrades system performance or attacks your system. Making your Mac once again your... Read more
Safari Technology Preview 14.1 - The new...
Safari Technology Preview contains the most recent additions and improvements to WebKit and the latest advances in Safari web technologies. And once installed, you will receive notifications of... Read more
Mactracker 7.9.7 - Database of all Mac m...
Mactracker provides detailed information on every Mac computer ever made, including items such as processor speed, memory, optical drives, graphic cards, supported OS X versions, and expansion... Read more
Tor Browser 10.0.2 - Anonymize Web brows...
The Tor Browser Bundle is an easy-to-use portable package of Tor, Vidalia, Torbutton, and a Firefox fork preconfigured to work together out of the box. It contains a modified copy of Firefox that... Read more
iTubeDownloader 6.5.24 - Easily download...
iTubeDownloader is a powerful-yet-simple YouTube downloader for the masses. Because it contains a proprietary browser, you can browse YouTube like you normally would. When you see something you want... Read more
TeamViewer 15.11.6 - Establish remote co...
TeamViewer gives you remote control of any computer or Mac over the Internet within seconds, or can be used for online meetings. Find out why more than 200 million users trust TeamViewer! Free for... Read more
ffWorks 2.1.18 - Convert multimedia file...
ffWorks, focused on simplicity, brings a fresh approach to the use of FFmpeg, allowing you to create ultra-high-quality movies without the need to write a single line of code on the command-line.... Read more

Latest Forum Discussions

See All

Lamplight City is a detective adventure...
Lamplight City is a steampunk adventure game that's available now for iOS after previously launching on PC. It sees players take on the role of private investigator Miles Fordham who is trying to get justice for his clients whilst tracking down... | Read more »
Genshin Impact Progression Guide - Mid-G...
Once you get up to around Adventure Rank 25, Genshin Impact starts to turn into a different thing. What was once a story-driven affair evolves into something more like a traditional MMO. | Read more »
Pixboy, the hit retro-themed platformer,...
Following its successful debut on PC and Nintendo Switch last summer, retro-themed platformer Pixboy has made the lead to mobile devices. The award-winning indie hit, which was developed by a two-person team at Oaky Games, has drawn comparisons to... | Read more »
Raziel: Dungeon Arena's newest char...
Raziel: Dungeon Arena's October update offers a little bit more than usual Halloween-themed outfits you often get this time of year, though those are here too. But beyond that, there is a new character, mercenary system and much more. In need of... | Read more »
Genshin Impact - Marvelous Merchant Even...
We're month since Genshin Impact's initial release, and we're already here at our second event. The Marvelous Merchant event has already been underway for two days and we have just the info you need to complete this silly scavenger hunt each day... | Read more »
Crash Bandicoot: On The Run! spins onto...
There’s a Crash Bandicoot endless runner coming to mobile sometime next spring. [Read more] | Read more »
Mulled 2 is a refreshingly simple ball-p...
Some of the greatest mobile games are actually the simplest ones, and it’s this philosophy that Mulled 2 was built on. Out now for iOS and Android, the puzzle sequel takes the accessible mechanics of its predecessor and builds on them with enticing... | Read more »
Physics-based tower defense game Goblin...
Indie developer Arif Games has released Goblin Raiders on iOS and Android. [Read more] | Read more »
PUBG Mobile has provided yet another upd...
PUBG Mobile has been making a point of publicly mentioning all of their ongoing efforts to vanquish cheating from the popular battle royale. Today two teams within the company have provided updates on their progress. [Read more] | Read more »
Zombieland: AFK Survival is celebrating...
Zombieland: AFK Survival is currently celebrating its one-year anniversary. If you don't quite recognise the name that's because it initially launched as Zombieland: Double Tapper. Anyway, the game is celebrating turning one with two Halloween-... | Read more »

Price Scanner via MacPrices.net

Apple now offering $8000 discount on maxed Ma...
Apple’s powerful Mac Pro can be fully optioned to a max of $53,399 by choosing a 2.5GHz 28-core Xeon W CPU, 1.5TB of memory, Two Radeon Pro Vega II Duo video cards with 2x32GB memory each, 8TB of... Read more
How to save $100-$200 on a new MacBook with A...
Are you a teacher, student, or staff member of any educational institution and need a new Apple MacBook? When you purchase a new MacBook using Apple’s Education discount, Apple will take $100-$200... Read more
Amazon offers Apple Watch Series 6 and SE dis...
Amazon is among the first Apple resellers to offer sale prices on new Apple Watch Series 6 and Apple Watch SE models with models available for up to $25 off Apple’s MSRP. These are the same Watches... Read more
3rd generation 12.9″ iPad Pros available toda...
Apple restocked select 3rd generation 12.9″ WiFi iPad Pros starting at only $699 and up to $380 off original MSRP. Each iPad comes with a standard Apple one-year warranty, outer cases are new, and... Read more
Upgrading To The iPhone 12 And Making The Swi...
FEATURE: 10.28.20 – The future of wireless technology is here but before you can jump onto the 5G bandwagon, you’ll need to upgrade to a compatible device like one of the new iPhones Apple... Read more
Gazelle drops prices on Apple’s iPhone 11 mod...
Gazelle is offering a range of discounted pre-owned unlocked Apple iPhone 11 models starting at $475, with some models seeing price reductions of up to $200. iPhones are offered in Fair, Good, and... Read more
B&H Photo has 2020 13″ Dual-Core MacBook...
B&H Photo has 2020 13″ Dual-Core MacBook Airs on sale today for $100 off Apple’s MSRP, only $899. Expedited shipping is free to many addresses in the US. These MacBook Airs are the same models... Read more
New promo at Verizon: New 64GB iPhone 11 Pro...
Verizon is offering the new 64GB iPhone 11 Pro Max for free for customers switching and opening a new line of service. Qualified trade-in required, worth up to $850 credited to your account over a 24... Read more
Apple has 2020 13″ 1.4GHz MacBook Pros in sto...
Apple has Certified Refurbished 2020 13″ 1.4GHz/256GB 4-Core Touch Bar MacBook Pros available for $1099, $200 off MSRP. Apple’s one-year warranty is included, shipping is free, and each MacBook has a... Read more
Amazon offers $50 discount on all new 2020 12...
Amazon has new 2020 Apple 12.9″ iPad Pros on sale today for $50 off MSRP, with prices starting at $949. Shipping is free. These are the same iPad Pros sold by Apple in their retail and online stores... Read more

Jobs Board

Licensed Dental Hygienist - *Apple* Valley...
Park Dental Apple Valley is seeking a compassionate, professional Dental Hygienist to join our team-oriented practice. Clinical Requirements Minnesota Licensure and Read more
Deskside Support Technician - *Apple* , Wind...
Deskside Support Technician - Apple , Windows **Ref No.:** 20-01859 **Location:** Northridge, California As part of a leading IT managed services specialist with more Read more
*Apple* Computing Specialist - Best Buy (Uni...
**789374BR** **Job Title:** Apple Computing Specialist **Job Category:** Store Associates **Store Number or Department:** 000896-Atlanta GA-Store **Job Read more
Geek Squad Advanced Repair *Apple* Professi...
**789256BR** **Job Title:** Geek Squad Advanced Repair Apple Professional **Job Category:** Store Associates **Store Number or Department:** 001135-Gulf Coast-Store Read more
Cub Foods - *Apple* Valley - Now Hiring Par...
Cub Foods - Apple Valley - Now Hiring Part Time! United States of America, Minnesota, Apple Valley Retail Post Date 1 day ago Requisition # 124800 Sign Up for Read more
All contents are Copyright 1984-2011 by Xplain Corporation. All rights reserved. Theme designed by Icreon.