iOS Questions (Persistence & Databases)

 Core Data 

  1. Core Data is a framework used to save, track, modify and filter the data within iOS apps, however, Core Data is not a Database.
  2. It allows data organised by the relational entity–attribute model to be serialised into XML, binary, or SQLite stores.
  3. Core Data is using SQLite as its persistent store but the framework itself is not the database.
  4. Core Data is an ORM (Object Relational Model) which creates a layer between the database and the UI.
  5. It speeds-up the process of interaction as we don’t have to write queries, just work with the ORM and let ORM handles the backend.


Core Data stack

- Manage and persist your app’s model layer.

  • A stack contains all the Core Data components you need to fetch, create, and manipulate managed objects.

  • Core Data provides a set of classes that collaboratively support your app’s model layer: (through fetch , create, manipulate manage objects)

A Core Data stack is composed of the following objects: 

1. NSManagedObjectContext:


  • A managed object context that provides a scratch pad for managed objects.

  • The NSManagedObjectContext object manages a collection of model objects, instances of the NSManagedObject class
  • An instance of NSManagedObjectContext tracks changes to instances of your app’s types.
  • view context was associated with the main queue. 

  • To perform data processing on a background queue as it can be CPU intensive. Examples like importing JSON into Core Data could otherwise block the view context and result in unresponsiveness in the user interface.

    The solution is to make use of a background managed object context. The latest APIs make it easy to create a new context from your persistent container:

  • let backgroundContext = persistentContainer.newBackgroundContext()
  • persistentContainer.performBackgroundTask { (backgroundContext) in
    // .. Core Data Code
}

NSManagedObjectModel is a database schema that describes the application's entities. It defines the structure of the managed objects. 
The managed object model, an instance of the NSManagedObjectModel class, loads the data model and exposes it to the Core Data stack.

To generate the class file initially: Choose Editor > Create NSManagedObject Subclass from the menu at the top of the screen. Select your data model, then the appropriate entity, and choose where to save the files. Xcode places both class and properties files into your project.

3. NSPersistentStoreCoordinator

  • The persistent store coordinator ( NSPersistentStoreCoordinator ) is the intermediary between the actual files that object data is stored in and the object model that the app interacts with.
  • An instance which saves and fetches instances of your app’s types from stores.
  • It has a reference to a managed object model that describes the entities in the store or stores it manages. The coordinator is the central object in a Core Data stack.

Persistent store : A persistent store is a repository in which managed objects may be stored. You can think of a persistent store as a database data file where individual records each hold the last-saved values of a managed object. Core Data offers three native file types for a persistent store: binary, XML, and SQLite.


/* code


func saveContext () {

        let context = persistentContainer.viewContext //NSManagedObjectContext

        if context.hasChanges {

            do {

                try context.save()

            } catch {

                let nserror = error as NSError

                fatalError("Unresolved error \(nserror), \(nserror.userInfo)")

            }

        }

    }



*/


- An instance of NSPersistentContainer includes all objects needed to represent a functioning Core Data stack, and provides convenience methods and properties for common patterns.

NSPersistentContainer: 

  • A container that encapsulates the Core Data stack in your app.
  • Inside AppDelegate.swift there is a propery called 'persistentContainer', this is used to assign data model file like CoreDataSample.xcdatamodeld.
  • It Load stores from the storeDescriptions property that have not already been successfully added to the container. The completion handler is called once for each store that succeeds or fails.
  • The AppDelegate.swift file will have Core Data Stack code inside the file



      /* 

        let container = NSPersistentContainer(name: "coreDataSample")

          //coreDataSample.xcdatamodeld


        container.loadPersistentStores(completionHandler: { (storeDescription, error) in 


         }

      */




  


Comments

Post a Comment

Popular posts from this blog

iOS Questions (Swift Programming Language)

Image
  1. What’s the difference between  var  and  let ?  Both var and let are references, therefore let is a const reference. let is used to declare a constant value - you won't change it after giving it an initial value. Its a immutable variable. let theAnswer = 42 The theAnswer cannot be changed afterwards. This is why anything weak can't be written using let. They need to change during runtime and you must be using var instead. The var defines an ordinary variable. What is interesting: The value of a constant doesn’t need to be known at compile time, but you must assign the value exactly once. Another strange feature: You can use almost any character you like for constant and variable names, including Unicode characters: let 🐶🐮 = "dogcow" let defines a "constant". Its value is set once and only once, though not necessarily when you declare it. For example, you use let to define a property in a class that must be set during initialization: var is used to dec...
Read more

Dispatch techniques: Dynamic dispatch and Static Dispatch

4 types of dispatch techniques — Inline  (Fastest) Static Dispatch Virtual Dispatch Dynamic Dispatch  (Slowest) Dynamic dispatch Swift  allows a class to override methods and properties declared in its superclasses. ... This technique, called  dynamic dispatch , increases language expressivity at the cost of a constant amount of runtime overhead for each indirect usage. Method Dispatch is the mechanism that helps to decide which operation should be executed, or more specifically, which method implementation should be used. Dynamic Dispatch  is supported only by  reference types ( i.e.  Class). The reason for this is that, for  dynamism , or  dynamic dispatch,  in short, we need  inheritance  and our  value types  do not support inheritance. To achieve  Dynamic Dispatch , we use inheritance, subclass a base class and then override an existing method of the base class. Also, we can make use of  dynamic  k...
Read more

What’s the difference between var and let? Which one would you choose for properties in a struct and Class why?

Image
Let is an immutable variable, meaning that it cannot be changed, other languages call this a constant. Var is a mutable variable, meaning that it can be changed.   “Use let to make a constant and var to make a variable” let aPerson = Person (name: Foo , first: Bar ) //< data of aPerson are changeable, not the reference var aPerson = Person (name: Foo , first: Bar ) //< both reference and data are changeable. var aPersonA = Person (name: A , first: a) var aPersonB = Person (name: B , first: b) aPersonA = aPersonB //aPersonA now refers to Person (name: B , first: b) Value and Reference Type Reference Type(Class) Swift's  classes  are  mutable  a-priory var  +  class It can be  reassigned  or  changed let  +  class  =  constant of address It can  not  be  reassigned  and can be  changed Value(Struct, Enum) Swift's  struct  can change th...
Read more