Core Data Flashcards
Technical answer what is Core Data
Core Data is an object graph management and persistence framework in the OS X and iOS SDKs.
That means Core Data can store and retrieve data, but it isn’t a relational database like MySQL or SQLite. Although it can use SQLite as the data store behind the scenes, you don’t think about Core Data in terms of tables and rows and primary ke
Technical answer what is Core Data
Core Data is an object graph management and persistence framework in the OS X and iOS SDKs.
That means Core Data can store and retrieve data, but it isn’t a relational database like MySQL or SQLite. Although it can use SQLite as the data store behind the scenes, you don’t think about Core Data in terms of tables and rows and primary keys.
What is NSPersistentContainer?
The NSPersistentContainer consists of a set of objects that facilitate saving and retrieving information from Core Data. Inside this container is an object to manage the Core Data state as a whole, an object representing the Data Model, and so on.
What managed object model
describes the way Core Data represents data on disk.
What is entity in coreData?
An entity is a class definition in Core Data. The classic example is an Employee or a Company. In a relational database, an entity corresponds to a table.
What is attribute in coreData?
An attribute is a piece of information attached to a particular entity. For example, an Employee entity could have attributes for the employee’s name, position and salary. In a database, an attribute corresponds to a particular field in a table.
What is relationship in coreData?
A relationship is a link between multiple entities. In Core Data, relationships between two entities are called to-one relationships, while those between one and many entities are called to-many relationships. For example, a Manager can have a to-many relationshipwith a set of employees, whereas an individual Employee will usually have a to-one relationshipwith his manager.
What NSManagedObject represents?
NSManagedObject represents a single object stored in Core Data; you must use it to create, edit, save and delete from your Core Data persistent store. NSManagedObject is a shape-shifter. It can take the form of any entity in your Data Model, appropriating whatever attributes and relationships you defined.
An NSManagedObject is a run-time representation of a Core Data entity. You can read and write to its attributes using Key-Value Coding.
What is KVC
KVC is a mechanism in Foundation for accessing an object’s properties indirectly using strings. KVC makes NSMangedObject behave somewhat like a dictionary at runtime.
Key-value coding is available to all classes inheriting from NSObject, including NSManagedObject. You can’t access properties using KVC on a Swift object that doesn’t descend from NSObject.
Way Core Data provides to read the value
The only way Core Data provides to read the value is key-value coding, commonly referred to as KVC.
Saving to Core Data
1. Before you can save or retrieve anything from your Core Data store, you first need to get your hands on an NSManagedObjectContext. You can consider a managed object context as an in-memory "scratchpad" for working with managed objects. Think of saving a new managed object to Core Data as a two-step process: first, you insert a new managed object into a managed object context; once you're happy, you "commit" the changes in your managed object context to save it to disk. Xcode has already generated a managed object context as part of the new project's template. Remember, this only happens if you check the Use Core Datacheckbox at the beginning. This default managed object context lives as a property of the NSPersistentContainer in the application delegate. To access it, you first get a reference to the app delegate. 2. You create a new managed object and insert it into the managed object context. You can do this in one step with NSManagedObject's static method: entity(forEntityName:in:). You may be wondering what an NSEntityDescription is all about. Recall earlier, NSManagedObject was called a shape-shifter class because it can represent any entity. An entity description is the piece linking the entity definition from your Data Model with an instance of NSManagedObject at runtime. 3. With an NSManagedObject in hand, you set the name attribute using key-value coding. You must spell the KVC key (name in this case) exactly as it appears in your Data Model, otherwise, your app will crash at runtime. 4. You commit your changes to person and save to disk by calling save on the managed object context. Note save can throw an error, which is why you call it using the try keyword within a do-catch block. Finally, insert the new managed object into the people array so it shows up when the table view reloads.
~~~
func save(name: String) {
guard let appDelegate =
UIApplication.shared.delegate as? AppDelegate else {
return
}
// 1
let managedContext =
appDelegate.persistentContainer.viewContext
// 2
let entity =
NSEntityDescription.entity(forEntityName: “Person”,
in: managedContext)!
let person = NSManagedObject(entity: entity,
insertInto: managedContext)
person.setValue(name, forKeyPath: “name”)
// 4
do {
try managedContext.save()
people.append(person)
} catch let error as NSError {
print(“Could not save. (error), (error.userInfo)”)
}
}
Fetching from Core Data step by step
override func viewWillAppear(_ animated: Bool) {
super.viewWillAppear(animated)
//1
guard let appDelegate =
UIApplication.shared.delegate as? AppDelegate else {
return
}
let managedContext =
appDelegate.persistentContainer.viewContext
//2
let fetchRequest =
NSFetchRequest(entityName: “Person”)
//3
do {
people = try managedContext.fetch(fetchRequest)
} catch let error as NSError {
print(“Could not fetch. (error), (error.userInfo)”)
}
}
Step by step, this is what the code does:
1. Before you can do anything with Core Data, you need a managed object context. Fetching is no different! Like before, you pull up the application delegate and grab a reference to its persistent container to get your hands on its NSManagedObjectContext.
2. As the name suggests, NSFetchRequest is the class responsible for fetching from Core Data. Fetch requests are both powerful and flexible. You can use fetch requests to fetch a set of objects meeting the provided criteria (i.e. give me all employees living in Wisconsin and have been with the company at least three years), individual values (i.e. give me the longest name in the database) and more. Fetch requests have several qualifiers used to refine the set of results returned. You'll learn more about these qualifiers in Chapter 4, "Intermediate Fetching"; for now, you should know NSEntityDescription is one of these required qualifiers. Setting a fetch request's entity property, or alternatively initializing it with init(entityName:), fetches /all/objects of a particular entity. This is what you do here to fetch all Person entities. Also note NSFetchRequest is a generic type. This use of generics specifies a fetch request's /expected/return type, in this case NSManagedObject.
- You hand the fetch request over to the managed object context to do the heavy lifting. fetch(_:) returns an array of managed objects meeting the criteria specified by the fetch request.
Note: Like save(), fetch(_:) can also throw an error so you have to use it within a do block. If an error occurred during the fetch, you can inspect the error inside the catch block and respond appropriately.
Note: There were a few rough edges in this sample app: you had to get the managed object context from the app delegate each time, and you used KVC to access an entity’s attributes rather than a more natural object-style person.name.
There are better ways to save and fetch data from Core Data, which you’ll explore in future chapters. The purpose of doing it the “long way” here is to learn what’s going on behind the scenes!
What persistence Core Data provides?
on-disk persistence, which means your data will be accessible even after terminating your app or shutting down your device. This is different from in-memory persistence, which will only save your data as long as your app is in memory, either in the foreground or in the background.
Data Model editor what is?
you can use to create your managed object model.
For what you need NSManagedObjectContext?
You need an NSManagedObjectContext to save() or fetch(_:) data to and from Core Data.
What Subclassing NSManagedObject do?
This creates a direct one-to-one mapping between entities in the data model editor and classes in your code. This means in some parts of your code, you can work with objects and properties without worrying too much about the Core Data side of things.
Storing non-standard data types in Core Data
You can save any data type to Core Data (even ones you define) using the Transformable
type as long as your type conforms to the NSCoding protocol.
Note:The NSCoding protocol (not to be confused with Swift’s Codable protocol) is a simple way to archive and unarchive objects that descend
The best alternative to key-value coding (CoreData)
create NSManagedObject subclasses for each entity in your data model. That means there will be a Bowtie class with correct types for each property.
What @NSManaged attribute informs?
Similar to @dynamic in Objective-C, the @NSManaged attribute informs the Swift compiler that the backing store and implementation of a property will be provided at runtime instead of compile time.
The normal pattern is for a property to be backed by an instance variable in memory. A property on a managed object is different: It’s backed by the managed object context, so the source of the data is not known at compile time.
Core Data entities and has two main benefits:
- Managed object subclasses unleash the syntactic power of Swift properties. By accessing attributes using properties instead of key-value coding, you befriend Xcode and the compiler.
- You gain the ability to override existing methods or to add your own. Note there are some NSManagedObject methods you must never override. Check Apple’s documentation of NSManagedObject for a complete list.
2 approaches in where to keep managed object context
a global variable in appDelegate vs pass the managed object context from class to class via a property.
CoreData have its own errors?
Yes, you check them in do-catch block
When an NSError is involved, it’s standard practice to check the domain and code for the error to determine what went wrong
attribute data types in coreData
Core Data supports different attribute data types, which determines the kind of data you can store in your entities and how much space they will occupy on disk. Some common attribute data types are String, Date, and Double.
The Binary Data attribute data type
The Binary Data attribute data type gives you the option of storing arbitrary amounts of binary data in your data model.
