{"id":1312,"date":"2014-10-15T11:10:27","date_gmt":"2014-10-15T17:10:27","guid":{"rendered":"http:\/\/jamesonquave.com\/blog\/?p=1312"},"modified":"2015-02-16T16:14:17","modified_gmt":"2015-02-16T22:14:17","slug":"core-data-in-swift-tutorial-part-2","status":"publish","type":"post","link":"https:\/\/jamesonquave.com\/blog\/core-data-in-swift-tutorial-part-2\/","title":{"rendered":"Core Data in Swift Tutorial (Part 2)"},"content":{"rendered":"

This post compatible with Xcode 6.3, Updated on February 16, 2015<\/strong><\/p>\n

This is part two of a tutorial series covering the usage of Core Data in Swift to write iOS apps with persistence. If you haven’t read part one yet, read that first<\/a>.<\/p>\n

If you really want to get your feet wet, my Swift book which is now available for pre-order<\/a> with early access.<\/p>\n

Creating more records<\/strong><\/p>\n

First off, if we’re going to do anything more interesting than just showing a single record pop up in an alert, we’ll need to generate some more records to play with. Let’s open up our LogItem.swift file and add a helper function for adding new records.<\/p>\n

Basically, we want to be able to simply call a method on the LogItem class, pass in some parameters, and get a new LogItem back.<\/p>\n

For example, when we’re done the actual function call might look like this:<\/p>\n

\r\nlet newItem = LogItem.createInManagedObjectContext(managedObjectContext, \"Item Title\", \"Item text\")\r\n<\/pre>\n
The LogItem class is not tied to any specific NSManagedObjectContext, so we want to make sure we aren’t storing the reference to the managed object context anywhere in the model, it needs to be passed in when we want to create an object like this.<\/p>\n
Okay so let’s implement the method in LogItem.swift:<\/p>\n
\r\nclass LogItem: NSManagedObject {\r\n\r\n    @NSManaged var itemText: String\r\n    @NSManaged var title: String\r\n\r\n    class func createInManagedObjectContext(moc: NSManagedObjectContext, title: String, text: String) -> LogItem {\r\n        let newItem = NSEntityDescription.insertNewObjectForEntityForName(\"LogItem\", inManagedObjectContext: moc) as! LogItem\r\n        newItem.title = title\r\n        newItem.itemText = text\r\n        \r\n        return newItem\r\n    }\r\n    \r\n}\r\n<\/pre>\n
The first line is the function definition. It’s a class function called createInManagedObjectContext<\/i>, which takes an object of type NSManagedObjectContext<\/b> as the argument moc<\/i>, a String<\/b> called title<\/i>, and a String<\/b> called text<\/i>. The function returns a LogItem<\/b> object that’s been inserted in to the specified managed object context.<\/p>\n
Then it executes nearly identical code as before to create a new LogItem object, except now it’s using the arguments passed in to the function to set up the new LogItem object.<\/p>\n
We can replace our original code in ViewController.swift now to just use the new method. Let’s add a bunch of new items…<\/p>\n
\r\noverride func viewDidLoad() {\r\n    super.viewDidLoad()\r\n    \/\/ Do any additional setup after loading the view, typically from a nib.\r\n    \r\n    \/\/ Use optional binding to confirm the managedObjectContext\r\n    if let moc = self.managedObjectContext {\r\n        \r\n        \/\/ Create some dummy data to work with\r\n        var items = [\r\n            (\"Best Animal\", \"Dog\"),\r\n            (\"Best Language\",\"Swift\"),\r\n            (\"Worst Animal\",\"Cthulu\"),\r\n            (\"Worst Language\",\"LOLCODE\")\r\n        ]\r\n        \r\n        \/\/ Loop through, creating items\r\n        for (itemTitle, itemText) in items {\r\n            \/\/ Create an individual item\r\n            LogItem.createInManagedObjectContext(moc,\r\n                title: itemTitle, text: itemText)\r\n        }\r\n    }\r\n}\r\n<\/pre>\n
To keep the code simple, we’re using some shortcuts in order to seed our data. What you’re seeing when I’m setting items<\/strong> is an array (using square brackets []), then each element is a tuple of two String values, [(String, String)]<\/strong>.<\/p>\n
Next, I’m decomposing them back in to two variables, itemTitle and itemText for each of the tuples in the array.<\/p>\n
Finally, I call the createInManagedObjectContext method, which we created earlier, passing in the new itemTitle and itemText.<\/p>\n

\nIf you already know how to set up a UITableView programmatically and want to skip ahead to the Core Data stuff, click here<\/a>.
\n<\/i><\/p>\n
Now that we have a couple of records, let’s remove presentItemInfo<\/strong> and instead opt for a table view here. We’ll add this all right under viewDidLoad and programmatically create the UITableView. In my iTunes tutorial<\/a> we do this using storyboards. If you are more interested in working with storyboards I recommend taking a pit stop there to read about how to get that set up.<\/p>\n
We’ll set up the tableView by adding a logTableView<\/strong> to the ViewController class, and set it all up in viewDidLoad()<\/p>\n
\r\n\/\/ Create the table view as soon as this class loads\r\nvar logTableView = UITableView(frame: CGRectZero, style: .Plain)\r\n\r\noverride func viewDidLoad() {\r\n    super.viewDidLoad()\r\n    \/\/ Do any additional setup after loading the view, typically from a nib.\r\n    \r\n    \/\/ Use optional binding to confirm the managedObjectContext\r\n    if let moc = self.managedObjectContext {\r\n        \r\n        \/\/ Create some dummy data to work with\r\n        var items = [\r\n            (\"Best Animal\", \"Dog\"),\r\n            (\"Best Language\",\"Swift\"),\r\n            (\"Worst Animal\",\"Cthulu\"),\r\n            (\"Worst Language\",\"LOLCODE\")\r\n        ]\r\n        \r\n        \/\/ Loop through, creating items\r\n        for (itemTitle, itemText) in items {\r\n            \/\/ Create an individual item\r\n            LogItem.createInManagedObjectContext(moc,\r\n                title: itemTitle, text: itemText)\r\n        }\r\n        \r\n        \r\n        \/\/ Now that the view loaded, we have a frame for the view, which will be (0,0,screen width, screen height)\r\n        \/\/ This is a good size for the table view as well, so let's use that\r\n        \/\/ The only adjust we'll make is to move it down by 20 pixels, and reduce the size by 20 pixels\r\n        \/\/ in order to account for the status bar\r\n        \r\n        \/\/ Store the full frame in a temporary variable\r\n        var viewFrame = self.view.frame\r\n        \r\n        \/\/ Adjust it down by 20 points\r\n        viewFrame.origin.y += 20\r\n        \r\n        \/\/ Reduce the total height by 20 points\r\n        viewFrame.size.height -= 20\r\n        \r\n        \/\/ Set the logTableview's frame to equal our temporary variable with the full size of the view\r\n        \/\/ adjusted to account for the status bar height\r\n        logTableView.frame = viewFrame\r\n        \r\n        \/\/ Add the table view to this view controller's view\r\n        self.view.addSubview(logTableView)\r\n        \r\n        \/\/ Here, we tell the table view that we intend to use a cell we're going to call \"LogCell\"\r\n        \/\/ This will be associated with the standard UITableViewCell class for now\r\n        logTableView.registerClass(UITableViewCell.classForCoder(), forCellReuseIdentifier: \"LogCell\")\r\n        \r\n        \/\/ This tells the table view that it should get it's data from this class, ViewController\r\n        logTableView.dataSource = self\r\n        \r\n    }\r\n}\r\n<\/pre>\n
Since we set the dataSource to be our ViewController class, we also need to adhere to the UITableViewDataSource protocol, so add that to the ViewController’s class definition:<\/p>\n
\r\nclass ViewController: UIViewController, UITableViewDataSource {\r\n<\/pre>\n
…and add the actual dataSource methods…<\/p>\n
\r\n\/\/ MARK: UITableViewDataSource\r\nfunc tableView(tableView: UITableView, numberOfRowsInSection section: Int) -> Int {\r\n    return 5\r\n}\r\n\r\nfunc tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell {\r\n    let cell = tableView.dequeueReusableCellWithIdentifier(\"LogCell\") as! UITableViewCell\r\n    cell.textLabel?.text = \"\\(indexPath.row)\"\r\n    return cell\r\n}\r\n<\/pre>\n
Still with me? Hope so… if not here’s the full ViewController.swift code up until this point. Note that we also removed the viewDidAppear function since we were only using that for testing out some things earlier.<\/p>\n
\r\nimport UIKit\r\nimport CoreData\r\n\r\nclass ViewController: UIViewController, UITableViewDataSource {\r\n    \r\n    \/\/ Retreive the managedObjectContext from AppDelegate\r\n    let managedObjectContext = (UIApplication.sharedApplication().delegate as! AppDelegate).managedObjectContext\r\n\r\n    \/\/ Create the table view as soon as this class loads\r\n    var logTableView = UITableView(frame: CGRectZero, style: .Plain)\r\n\r\n    override func viewDidLoad() {\r\n        super.viewDidLoad()\r\n        \/\/ Do any additional setup after loading the view, typically from a nib.\r\n        \r\n        \/\/ Use optional binding to confirm the managedObjectContext\r\n        if let moc = self.managedObjectContext {\r\n            \r\n            \/\/ Create some dummy data to work with\r\n            var items = [\r\n                (\"Best Animal\", \"Dog\"),\r\n                (\"Best Language\",\"Swift\"),\r\n                (\"Worst Animal\",\"Cthulu\"),\r\n                (\"Worst Language\",\"LOLCODE\")\r\n            ]\r\n            \r\n            \/\/ Loop through, creating items\r\n            for (itemTitle, itemText) in items {\r\n                \/\/ Create an individual item\r\n                LogItem.createInManagedObjectContext(moc,\r\n                    title: itemTitle, text: itemText)\r\n            }\r\n            \r\n            \r\n            \/\/ Now that the view loaded, we have a frame for the view, which will be (0,0,screen width, screen height)\r\n            \/\/ This is a good size for the table view as well, so let's use that\r\n            \/\/ The only adjust we'll make is to move it down by 20 pixels, and reduce the size by 20 pixels\r\n            \/\/ in order to account for the status bar\r\n            \r\n            \/\/ Store the full frame in a temporary variable\r\n            var viewFrame = self.view.frame\r\n            \r\n            \/\/ Adjust it down by 20 points\r\n            viewFrame.origin.y += 20\r\n            \r\n            \/\/ Reduce the total height by 20 points\r\n            viewFrame.size.height -= 20\r\n            \r\n            \/\/ Set the logTableview's frame to equal our temporary variable with the full size of the view\r\n            \/\/ adjusted to account for the status bar height\r\n            logTableView.frame = viewFrame\r\n            \r\n            \/\/ Add the table view to this view controller's view\r\n            self.view.addSubview(logTableView)\r\n            \r\n            \/\/ Here, we tell the table view that we intend to use a cell we're going to call \"LogCell\"\r\n            \/\/ This will be associated with the standard UITableViewCell class for now\r\n            logTableView.registerClass(UITableViewCell.classForCoder(), forCellReuseIdentifier: \"LogCell\")\r\n            \r\n            \/\/ This tells the table view that it should get it's data from this class, ViewController\r\n            logTableView.dataSource = self\r\n            \r\n        }\r\n    }\r\n    \r\n    \/\/ MARK: UITableViewDataSource\r\n    func tableView(tableView: UITableView, numberOfRowsInSection section: Int) -> Int {\r\n        return 5\r\n    }\r\n    \r\n    func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell {\r\n        let cell = tableView.dequeueReusableCellWithIdentifier(\"LogCell\") as! UITableViewCell\r\n        cell.textLabel?.text = \"\\(indexPath.row)\"\r\n        return cell\r\n    }\r\n\r\n    override func didReceiveMemoryWarning() {\r\n        super.didReceiveMemoryWarning()\r\n        \/\/ Dispose of any resources that can be recreated.\r\n    }\r\n\r\n}\r\n<\/pre>\n
This will give us a numbered list of rows if we run the app. This just confirms the table view is set up correctly.<\/p>\n
If you ever get an error that says something like, The model used to open the store is incompatible with the one used to create the store<\/b>
\nThis means that the model Core Data thinks it’s working with doesn’t quite match what’s been stored in the database. Resolving this with a live app means migrating between versions of your model. But for the purpose of learning and doing the initial development, usually the quickest way to just keep moving is to delete the app from the simulator; wiping out the data, and therefore resolving the conflict.<\/i><\/p>\n
<\/a><\/p>\n
Now that we have this all set up and ready to go, we can start working on getting our log data showing up in the table view.<\/p>\n
Please note that at this point in the tutorial, I’m intentionally avoiding the NSFetchedResultsController class. I’m doing this because I believe it will make more sense from the Core Data perspective the first time around if you see it done the old fashioned way. After this tutorial is over, I encourage you to look over the class and see how you might use it to implement some of these things instead. I think it is important to first learn how to implement a core data backed table view without using the helper class. The helper class is not applicable in all situations, and learning it first would be doing yourself a disservice. You’ll find it doesn’t work for all use cases (not even close), and in it’s magic it hides some of what’s going on.<\/i><\/p>\n
First off, let’s fetch all the results from Core Data in viewDidLoad(), and store them in an array of LogItem’s, logItems<\/strong>.<\/p>\n
First we’ll add the variable to the ViewController class:<\/p>\n
\r\n\/\/ Create an empty array of LogItem's\r\nvar logItems = [LogItem]()\r\n<\/pre>\n
Next, we’ll populate it from viewDidLoad(), inside of a function called fetchLog().<\/p>\n
\r\noverride func viewDidLoad() {\r\n    ...\r\n    fetchLog()\r\n}\r\n\r\nfunc fetchLog() {\r\n    let fetchRequest = NSFetchRequest(entityName: \"LogItem\")\r\n    if let fetchResults = managedObjectContext!.executeFetchRequest(fetchRequest, error: nil) as? [LogItem] {\r\n        logItems = fetchResults\r\n    }\r\n}\r\n<\/pre>\n
Now we can modify the tableView dataSource methods to refer to this array instead of hard-coding values.<\/p>\n
\r\n\/\/ MARK: UITableViewDataSource\r\nfunc tableView(tableView: UITableView, numberOfRowsInSection section: Int) -> Int {\r\n    \/\/ How many rows are there in this section?\r\n    \/\/ There's only 1 section, and it has a number of rows\r\n    \/\/ equal to the number of logItems, so return the count\r\n    return logItems.count\r\n}\r\n\r\nfunc tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell {\r\n    let cell = tableView.dequeueReusableCellWithIdentifier(\"LogCell\") as! UITableViewCell\r\n    \r\n    \/\/ Get the LogItem for this index\r\n    let logItem = logItems[indexPath.row]\r\n    \r\n    \/\/ Set the title of the cell to be the title of the logItem\r\n    cell.textLabel?.text = logItem.title\r\n    return cell\r\n}\r\n<\/pre>\n
This should set us up to see the items listed in the table view, but we want to show the text of an item when it’s clicked. So we need to set the table view to use this view controller as it’s delegate, so we can receive the callback method, didSelectRowAtIndexPath<\/strong>.<\/p>\n
Similar to before, add the UITableViewDelegate<\/strong> protocol to the class…<\/p>\n
\r\nclass ViewController: UIViewController, UITableViewDataSource, UITableViewDelegate {\r\n<\/pre>\n
And set the delegate to be self, you can do this right under where you set the dataSource in viewDidLoad…<\/p>\n
\r\n\/\/ This tells the table view that it should get it's data from this class, ViewController\r\nlogTableView.dataSource = self\r\nlogTableView.delegate = self\r\n<\/pre>\n
Finally we can implement the method, knowing the Table View will call it when a cell is clicked…<\/p>\n
\r\n\/\/ MARK: UITableViewDelegate\r\nfunc tableView(tableView: UITableView, didSelectRowAtIndexPath indexPath: NSIndexPath) {\r\n    let logItem = logItems[indexPath.row]\r\n    println(logItem.itemText)\r\n}\r\n<\/pre>\n
This will set us up so that when the button is clicked, a message will show in the console (in the Xcode window) showing the itemText for the clicked item.<\/p>\n
  <\/div>\n
The purpose of this tutorial is not really to explain how to set up a table view manually, but it’s sort of necessary in order to get a good look at the data. For this reason, I’m providing the source code up until this point in the tutorial here<\/a>. Feel free to simply check this out and work from this code base, from here we’ll be talking more about the Core Data side of things.
\nhttps:\/\/github.com\/jquave\/Core-Data-In-Swift-Tutorial\/tree\/Part1.5<\/a><\/p>\n
You may see something kind of like this now, except with different data:<\/p>\n
<\/a><\/p>\n
Your ordering may be different every time you run your app, this is because it contains no sorting when it performs the fetch request. In some data stores you might get this data back in the same order as it was inserted, but with Core Data it ends up being fairly random. Let’s change this by adding a sort to the fetch request.<\/p>\n
\r\nfunc fetchLog() {\r\n    let fetchRequest = NSFetchRequest(entityName: \"LogItem\")\r\n    \r\n    \/\/ Create a sort descriptor object that sorts on the \"title\"\r\n    \/\/ property of the Core Data object\r\n    let sortDescriptor = NSSortDescriptor(key: \"title\", ascending: true)\r\n    \r\n    \/\/ Set the list of sort descriptors in the fetch request,\r\n    \/\/ so it includes the sort descriptor\r\n    fetchRequest.sortDescriptors = [sortDescriptor]\r\n    \r\n    if let fetchResults = managedObjectContext!.executeFetchRequest(fetchRequest, error: nil) as? [LogItem] {\r\n        logItems = fetchResults\r\n    }\r\n}\r\n<\/pre>\n
Now the fetch request has it’s sortDescriptors property set. Note that this is an array, which is why we need the brackets around the single sortDescriptor<\/strong> we created using the title key. Running the app you should now see the sorted (alphabetically) list of items, much better. Note your data is expected to be different.<\/p>\n
<\/a><\/p>\n
Let’s also look at filtering out certain elements. First, let’s just try and only get the item named “Best Language”. We’ll create an NSPredicate that uses a string to represent the requirement that any object must fulfill in order to pass through the query.<\/p>\n
\r\nfunc fetchLog() {\r\n    let fetchRequest = NSFetchRequest(entityName: \"LogItem\")\r\n    \r\n    \/\/ Create a sort descriptor object that sorts on the \"title\"\r\n    \/\/ property of the Core Data object\r\n    let sortDescriptor = NSSortDescriptor(key: \"title\", ascending: true)\r\n    \r\n    \/\/ Set the list of sort descriptors in the fetch request,\r\n    \/\/ so it includes the sort descriptor\r\n    fetchRequest.sortDescriptors = [sortDescriptor]\r\n    \r\n    \/\/ Create a new predicate that filters out any object that\r\n    \/\/ doesn't have a title of \"Best Language\" exactly.\r\n    let predicate = NSPredicate(format: \"title == %@\", \"Best Language\")\r\n    \r\n    \/\/ Set the predicate on the fetch request\r\n    fetchRequest.predicate = predicate\r\n    \r\n    if let fetchResults = managedObjectContext!.executeFetchRequest(fetchRequest, error: nil) as? [LogItem] {\r\n        logItems = fetchResults\r\n    }\r\n}\r\n<\/pre>\n
If you haven’t seen the format syntax yet, or haven’t seen it in a while, it’s simple enough to say that any time you see format as a named parameter, it comes from the Objective-C methods “predicateWithFormat”, or “stringWithFormat”, and so on. This replaces any instances of the %@ symbol with an object’s description (the value of a string, or an otherwise useful representation of other types of objects). For primitive types such as an Int, you’ll want to instead opt for %i, %f for Float, and so on.<\/p>\n
So when you see
\n(format: “title == %@”, “Best Language”)<\/strong><\/p>\n
What the compiler sees is something like this:
\n(“title == ‘Best Language'”)<\/strong><\/p>\n
So we’re just specifying we want title to equal that exact string.<\/p>\n
Running the app now we should see just one item.<\/p>\n
We could also do a string comparison using the contains keyword, if we look for the substring “Worst” we’ll only get the items that contain that string…<\/p>\n
\r\n\/\/ Search for only items using the substring \"Worst\"\r\nlet predicate = NSPredicate(format: \"title contains %@\", \"Worst\")\r\n\r\n\/\/ Set the predicate on the fetch request\r\nfetchRequest.predicate = predicate\r\n<\/pre>\n
What if we wanted to combine the two though? We want both items containing the string “Worst” and any one with a title “Best Language”?<\/p>\n
First, let’s create the two separate predicates:<\/p>\n
\r\n\/\/ Create a new predicate that filters out any object that\r\n\/\/ doesn't have a title of \"Best Language\" exactly.\r\nlet firstPredicate = NSPredicate(format: \"title == %@\", \"Best Language\")\r\n\r\n\/\/ Search for only items using the substring \"Worst\"\r\nlet thPredicate = NSPredicate(format: \"title contains %@\", \"Worst\")\r\n<\/pre>\n
Then combine them using the NSCompoundPredicate constructor:<\/p>\n
\r\n\/\/ Combine the two predicates above in to one compound predicate\r\nlet predicate = NSCompoundPredicate(type: NSCompoundPredicateType.OrPredicateType, subpredicates: [firstPredicate, thPredicate])\r\n\r\n\/\/ Set the predicate on the fetch request\r\nfetchRequest.predicate = predicate\r\n<\/pre>\n
Since we want both cases of the “Best Language” and any item containing “Worst”, we use a compound predicate type of NSCompoundPredicateType.OrPredicateType<\/strong><\/p>\n
All this is just a confusing way of saying, “give me any items where the firstPredicate or<\/strong> the thPredicate is true.”<\/p>\n
What we did here is quite powerful in practice. We can use string comparison as predicates, and filter\/order large lists of data through Core Data. The Core Data API will then connect to the backing store (SQLite) and produce an efficient query to quickly retrieve the needed information. This is a very common pattern in iOS development, and understanding it is very important. So, if you got stuck on this tutorial or have any questions, don’t hesitate to ask for help on the forums<\/a>.<\/p>\n
This concludes Part 2 for now, in the next section we’ll move in to a more applicable scenario by adding a way for user’s to create log items, edit, save, and delete them.<\/p>\n
The complete source code to this section »<\/a><\/p>\n
\nPart 1<\/a>
\nPart 2<\/a>
\nPart 3<\/a>
\nPart 4<\/a>\n<\/div>\n
If you’re reading this scratching your head, or just want a deeper dive in to Core Data, be sure to look at my Swift book, which is now available for early access<\/a>. And don’t forget to subscribe to get updates<\/a> on this tutorial series via e-mail.<\/p>\n","protected":false},"excerpt":{"rendered":"
This post compatible with Xcode 6.3, Updated on February 16, 2015 This is part two of a tutorial series covering the usage of Core Data in Swift to write iOS apps with persistence. If you haven’t read part one yet, read that first. If you really want to get your feet wet, my Swift book…<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_links_to":"","_links_to_target":""},"categories":[25,10,32],"tags":[61,15,33,36],"yoast_head":"\nCore Data in Swift Tutorial (Part 2) - Jameson Quave<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/jamesonquave.com\/blog\/core-data-in-swift-tutorial-part-2\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Core Data in Swift Tutorial (Part 2) - Jameson Quave\" \/>\n<meta property=\"og:description\" content=\"This post compatible with Xcode 6.3, Updated on February 16, 2015 This is part two of a tutorial series covering the usage of Core Data in Swift to write iOS apps with persistence. If you haven’t read part one yet, read that first. If you really want to get your feet wet, my Swift book...\" \/>\n<meta property=\"og:url\" content=\"https:\/\/jamesonquave.com\/blog\/core-data-in-swift-tutorial-part-2\/\" \/>\n<meta property=\"og:site_name\" content=\"Jameson Quave\" \/>\n<meta property=\"article:published_time\" content=\"2014-10-15T17:10:27+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2015-02-16T22:14:17+00:00\" \/>\n<meta property=\"og:image\" content=\"http:\/\/jamesonquave.com\/blog\/wp-content\/uploads\/tableView.png\" \/>\n<meta name=\"author\" content=\"Jameson Quave\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Jameson Quave\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"14 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\/\/jamesonquave.com\/blog\/core-data-in-swift-tutorial-part-2\/\",\"url\":\"https:\/\/jamesonquave.com\/blog\/core-data-in-swift-tutorial-part-2\/\",\"name\":\"Core Data in Swift Tutorial (Part 2) - Jameson Quave\",\"isPartOf\":{\"@id\":\"https:\/\/jamesonquave.com\/blog\/#website\"},\"datePublished\":\"2014-10-15T17:10:27+00:00\",\"dateModified\":\"2015-02-16T22:14:17+00:00\",\"author\":{\"@id\":\"https:\/\/jamesonquave.com\/blog\/#\/schema\/person\/db6184f355c7f4e3b876d0f228c2fcfc\"},\"breadcrumb\":{\"@id\":\"https:\/\/jamesonquave.com\/blog\/core-data-in-swift-tutorial-part-2\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/jamesonquave.com\/blog\/core-data-in-swift-tutorial-part-2\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/jamesonquave.com\/blog\/core-data-in-swift-tutorial-part-2\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/jamesonquave.com\/blog\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Core Data in Swift Tutorial (Part 2)\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/jamesonquave.com\/blog\/#website\",\"url\":\"https:\/\/jamesonquave.com\/blog\/\",\"name\":\"Jameson Quave\",\"description\":\"Using computer technology to educate, and improve lives.\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/jamesonquave.com\/blog\/?s={search_term_string}\"},\"query-input\":\"required name=search_term_string\"}],\"inLanguage\":\"en-US\"},{\"@type\":\"Person\",\"@id\":\"https:\/\/jamesonquave.com\/blog\/#\/schema\/person\/db6184f355c7f4e3b876d0f228c2fcfc\",\"name\":\"Jameson Quave\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/jamesonquave.com\/blog\/#\/schema\/person\/image\/\",\"url\":\"https:\/\/secure.gravatar.com\/avatar\/d9786c83345117d560bbeab0e1f26814?s=96&d=retro&r=pg\",\"contentUrl\":\"https:\/\/secure.gravatar.com\/avatar\/d9786c83345117d560bbeab0e1f26814?s=96&d=retro&r=pg\",\"caption\":\"Jameson Quave\"},\"sameAs\":[\"http:\/\/jamesonquave.com\"],\"url\":\"https:\/\/jamesonquave.com\/blog\/author\/jquave\/\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Core Data in Swift Tutorial (Part 2) - Jameson Quave","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/jamesonquave.com\/blog\/core-data-in-swift-tutorial-part-2\/","og_locale":"en_US","og_type":"article","og_title":"Core Data in Swift Tutorial (Part 2) - Jameson Quave","og_description":"This post compatible with Xcode 6.3, Updated on February 16, 2015 This is part two of a tutorial series covering the usage of Core Data in Swift to write iOS apps with persistence. If you haven’t read part one yet, read that first. If you really want to get your feet wet, my Swift book...","og_url":"https:\/\/jamesonquave.com\/blog\/core-data-in-swift-tutorial-part-2\/","og_site_name":"Jameson Quave","article_published_time":"2014-10-15T17:10:27+00:00","article_modified_time":"2015-02-16T22:14:17+00:00","og_image":[{"url":"http:\/\/jamesonquave.com\/blog\/wp-content\/uploads\/tableView.png"}],"author":"Jameson Quave","twitter_card":"summary_large_image","twitter_misc":{"Written by":"Jameson Quave","Est. reading time":"14 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/jamesonquave.com\/blog\/core-data-in-swift-tutorial-part-2\/","url":"https:\/\/jamesonquave.com\/blog\/core-data-in-swift-tutorial-part-2\/","name":"Core Data in Swift Tutorial (Part 2) - Jameson Quave","isPartOf":{"@id":"https:\/\/jamesonquave.com\/blog\/#website"},"datePublished":"2014-10-15T17:10:27+00:00","dateModified":"2015-02-16T22:14:17+00:00","author":{"@id":"https:\/\/jamesonquave.com\/blog\/#\/schema\/person\/db6184f355c7f4e3b876d0f228c2fcfc"},"breadcrumb":{"@id":"https:\/\/jamesonquave.com\/blog\/core-data-in-swift-tutorial-part-2\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/jamesonquave.com\/blog\/core-data-in-swift-tutorial-part-2\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/jamesonquave.com\/blog\/core-data-in-swift-tutorial-part-2\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/jamesonquave.com\/blog\/"},{"@type":"ListItem","position":2,"name":"Core Data in Swift Tutorial (Part 2)"}]},{"@type":"WebSite","@id":"https:\/\/jamesonquave.com\/blog\/#website","url":"https:\/\/jamesonquave.com\/blog\/","name":"Jameson Quave","description":"Using computer technology to educate, and improve lives.","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/jamesonquave.com\/blog\/?s={search_term_string}"},"query-input":"required name=search_term_string"}],"inLanguage":"en-US"},{"@type":"Person","@id":"https:\/\/jamesonquave.com\/blog\/#\/schema\/person\/db6184f355c7f4e3b876d0f228c2fcfc","name":"Jameson Quave","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/jamesonquave.com\/blog\/#\/schema\/person\/image\/","url":"https:\/\/secure.gravatar.com\/avatar\/d9786c83345117d560bbeab0e1f26814?s=96&d=retro&r=pg","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/d9786c83345117d560bbeab0e1f26814?s=96&d=retro&r=pg","caption":"Jameson Quave"},"sameAs":["http:\/\/jamesonquave.com"],"url":"https:\/\/jamesonquave.com\/blog\/author\/jquave\/"}]}},"_links":{"self":[{"href":"https:\/\/jamesonquave.com\/blog\/wp-json\/wp\/v2\/posts\/1312"}],"collection":[{"href":"https:\/\/jamesonquave.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/jamesonquave.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/jamesonquave.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/jamesonquave.com\/blog\/wp-json\/wp\/v2\/comments?post=1312"}],"version-history":[{"count":52,"href":"https:\/\/jamesonquave.com\/blog\/wp-json\/wp\/v2\/posts\/1312\/revisions"}],"predecessor-version":[{"id":1653,"href":"https:\/\/jamesonquave.com\/blog\/wp-json\/wp\/v2\/posts\/1312\/revisions\/1653"}],"wp:attachment":[{"href":"https:\/\/jamesonquave.com\/blog\/wp-json\/wp\/v2\/media?parent=1312"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/jamesonquave.com\/blog\/wp-json\/wp\/v2\/categories?post=1312"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/jamesonquave.com\/blog\/wp-json\/wp\/v2\/tags?post=1312"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}