Objective-C Fundamentals

Core Data history
229
Structured Query Language (SQL). It was the primary method for persisting (or storing)
data on the iPhone. It got the job done, but it required a lot of overhead during
development. To use SQLite, you had to do everything “by hand”: You had to create
and initialize the database. You had to write SQL code for all CRUD (create, read,
update, and delete) operations. You had to manually set up and manage relationships.
And as a good object-oriented developer, you had to put the data you got from the
database into Objective-C data model objects and take data from those objects again
when you wanted to build a database query that updated, created, or deleted data. On
top of that, you had to manage primary and foreign keys, and so on and so forth. You
get the picture. It was no fun at all to write all that code.
Fortunately, Apple realized that too and brought the Core Data framework to the
iPhone with the 3.0 software development kit (SDK). Core Data can be compared to
ActiveRecord (if you know Ruby on Rails) or Hibernate (if you’re a Java developer). It
handles all the low-level nitty-gritty details of data persistence for you: you don’t have
to write SQL code, you don’t have to map between data and data objects, and you
don’t have to handle relationships (it won’t fix your marriage, though).
In this chapter, we take a high-level look at all the different moving parts of Core
Data and then get our hands dirty by building a simple Core Data application. Please
keep in mind that Core Data is an advanced topic, and it would take a whole book to
cover everything there is to know about it. But this chapter teaches you everything you
need to know to leverage Core Data for all your most common data persistence needs.
12.1 Core Data history
Nearly every application has a data model and model objects (people, invoices, products,
departments—you name it). And nearly every application has to save some or all
of that data to disk. Functionality that is needed by a substantial number of applications
and solutions to problems that developers face repeatedly calls for a framework.
That’s why Apple put this data modeling and persistence functionality into a framework
and called it Core Data. It was first introduced in 2005 with Mac OS X (10.4)
Tiger. Core Data is the M in MVC (model-view-controller). It takes care of the complete
model layer, including the relationships among the model objects, and makes it
extremely easy to save an object graph to and load it from disk.
Before we dive into using Core Data, let’s look into the objects that make Core
Data work.
12.1.1 What does Core Data do?
Core Data isn’t just a wrapper for database access. In most cases, however, Core Data
uses a SQLite database to store the data on disk. On Mac OS X, developers usually also
choose SQLite when working with Core Data, but the option to save the data in XML
format is available too, which shows that Core Data isn’t simply a database access
library. To explain what’s going on under the hood, we take a brief look at SQLite
because it’ll make some of the underpinnings easier to understand.