Data Persistence

UserDefaults

A Dictionary that periodically saves its contents to your device’s permanent storage (SSD).

• Great for storing user preferences and other simple things. e.g like check if the app has lunched before
• Saves data in a plist file (property list file).
• Can only store the following data types: Data, String, Number, Date, Array, and Dictionary.
• When storing (writing) the file or accessing (reading) the file, UserDefaults does it all at once, possibly creating long/unnecessary I/O time.
• It’s a good idea to keep UserDefaults under 1MB.

func checkIfFirstLaunch() {
    if UserDefaults.standard.bool(forKey: "hasLaunchedBefore") {
        print("App has launched before") 
    } else {
        print("This is the first launch ever!")
        UserDefaults.standard.set(true, forKey: "hasLaunchedBefore")
        UserDefaults.standard.set(false, forKey: "midnightThemeOn")
        UserDefaults.standard.synchronize()
    }
}

Sandbox

let fileManager = FileManager.default
let urls = fileManager.urls(for: .documentDirectory, in: .userDomainMask)
let url = urls.first?.appendingPathComponent("my.txt")

do {
    let str = "123"
    try str.write(to: url!, atomically: true, encoding: .utf8)
} catch {
    print("error")
}

do {
    let content = try String(contentsOf: url!, encoding: .utf8)
    print(content)
} catch {
    print("error")
}

Core Data

Core Data is a framework for creating modela and managing an app's data layer.

This includes the app's model (the data's structure and relationships), as well as code for changing the model and updating the UI when the model changes.

Core Data != Persistence Persistence is just one aspect of data layer management. But it is an important one!

How Does Core Data Save Data?

Persistent Stores

Core Data saves (or persists) data into something called a persistent store (think storage). The store is where the data lives.

Types of Stores

There are three different types of persistent stores Core Data supports on iOS:

• a SQLite store (the default)
• a binary store
• an in-memory store.

SQLite

SQLite is almost always the right choice for your persistent store; it means your data is stored in a SQL relational database, and there are a few handy features in Core Data (like model caching during migration) that only work with the SQLite store. And since you don’t interact with the persistent store directly, you don’t need to know any SQL to use the SQLite store.

In-memory

**The in-memory and binary stores have different characteristics in terms of memory usage and performance. The in-memory store can be appropriate when you have a small data model that can fit in memory all at once and that doesn’t need to be saved to disk – for example a cache.

Binary

The binary store can be appropriate when you always need the database to be read and written in its entirety—for example if you are using a file format such as CSV.

Abstracting the Store

Core Data abstracts the persistent store's details. That means you won’t usually interact with the store directly. You can think of Core Data as a layer that sits between your code and the underlying store, making it easier for the two to communicate.

Core Data provides a common interface for saving and fetching data, no matter what kind of store sits below. Whatever type of store you choose, you’ll always use the same Core Data classes to access and manage your data. And you won't need to learn a database-specific language to manage your data; you can do it all in Swift.

Entities

A way to define a piece of data, including its attributes and relationships

Attribute Types

Two-sided Relationships

Core Data uses two-sided relationships.

Core Data includes functionality to model deletion behavior. Modelling the relationship in both directions lets Core Data traverse the web of entity class instances (also known as the “object graph”) and make sure all affected references are updated. This is called referential integrity.

Deletion Rules

For our notes relationship, choosing the Cascade rule will mean that deleting a Notebook will cause all of its referenced notes to be deleted.

For our notebook relationship in Note, choosing Nullify means that the relationship will simply be removed, but the referenced Notebook remains.