Realm是哪种数据库？

Question

What kind of database is Realm ? Is it ORM ? Or does it work like object database? Maybe database structure somehow affects design processes? Is there any nuances in designing Realm database?

I'm asking here, because I haven't found any answers in official website

Answer 1

Unfortunately I do not actually use the iOS version, but I do use the Android version, which day by day is more and more similar in its feature set to the iOS version, and they share the same core , and they are closer to providing the same unified behavior via the object-store .

Most of this answer will therefore be based on the Swift API docs. (Realm Swift 2.6.1)

---

Realm is by default an object store. Technically it stores your data in a schema, where the schema is defined by classes, like

// from https://realm.io/docs/swift/latest/#models
class Person: Object {
    dynamic var name = ""
    dynamic var birthdate = NSDate(timeIntervalSince1970: 1)
    let dogs = List<Dog>()
}

Now what's interesting about Realm is that it is not a relational database; it stores the objects directly. In fact, objects managed by Realm (aka obtained via a query to Realm, or a newly created object made by Realm) map directly to the underlying Realm file, and do not copy the data to fields, the accessors directly read from and write to the Realm file.

This "direct access" results in that all data is loaded only when accessed (lazy-evaluation), therefore caching of managed objects is not needed(!).

All writes are transactional. Outside of transactions, managed RealmObjects cannot be modified.

---

Between your objects, you can have relationships (links):

// from https://realm.io/docs/swift/latest/#relationships
class Dog: Object {
    // ... other property declarations
    dynamic var owner: Person? // to-one relationships must be optional
}

class Person: Object {
    // ... other property declarations
    let dogs = List<Dog>() // to-many relationship
}

Any relationship (to-one, to-many) has their corresponding backlink , which you can define as "the objects that are linking to this object".

// from https://realm.io/docs/swift/latest/#relationships
class Dog: Object {
    dynamic var name = ""
    dynamic var age = 0
    let owners = LinkingObjects(fromType: Person.self, property: "dogs")
}

---

Realm's managed objects are "live, immutable views of the data" (from here ), which mutate in place, and you receive change notification about it via a notification token (from here ). The same applies to any managed RealmObject , but also query results .

Meaning, query results are automatically asynchronously evaluated, and only elements accessed at a given index are read from the database, in a lazy-loaded manner! Therefore, pagination is not needed.

Any writes on any thread automatically send a notification to threads associated with a run-loop, and the query results are automatically updated, and the change listener (notification block) is called.

// from https://realm.io/docs/swift/latest/#collection-notifications
  override func viewDidLoad() {
    super.viewDidLoad()
    let realm = try! Realm()
    let results = realm.objects(Person.self).filter("age > 5")

    // Observe Results Notifications
    notificationToken = results.addNotificationBlock { [weak self] (changes: RealmCollectionChange) in
      guard let tableView = self?.tableView else { return }
      switch changes {
      case .initial:
        // Results are now populated and can be accessed without blocking the UI
        tableView.reloadData()
        break
      case .update(_, let deletions, let insertions, let modifications):
        // Query results have changed, so apply them to the UITableView
        tableView.beginUpdates()
        tableView.insertRows(at: insertions.map({ IndexPath(row: $0, section: 0) }),
                           with: .automatic)
        tableView.deleteRows(at: deletions.map({ IndexPath(row: $0, section: 0)}),
                           with: .automatic)
        tableView.reloadRows(at: modifications.map({ IndexPath(row: $0, section: 0) }),
                           with: .automatic)
        tableView.endUpdates()
        break
      case .error(let error):
        // An error occurred while opening the Realm file on the background worker thread
        fatalError("\(error)")
        break
      }
    }
  }

  deinit {
    notificationToken?.stop()
  }

---

The most well-known limitation is that RealmObjects, RealmResults and Realms cannot be passed between threads . (Other limitations are here ).

A RealmObject/RealmResults/Realm on a given thread can only be accessed on the thread where its corresponding Realm instance was opened (read here ). (The exception is RealmObjects sent between threads using ThreadSafeReference , see here ).

Therefore, background threads require their own Realm instance, generally wrapped in an autoreleasepool , see here .

// from https://realm.io/docs/swift/latest/#using-a-realm-across-threads
DispatchQueue(label: "background").async {
  autoreleasepool {
    // Get realm and table instances for this thread
    let realm = try! Realm()

    // Break up the writing blocks into smaller portions
    // by starting a new transaction
    for idx1 in 0..<1000 {
      realm.beginWrite()

      // Add row via dictionary. Property order is ignored.
      for idx2 in 0..<1000 {
        realm.create(Person.self, value: [
          "name": "\(idx1)",
          "birthdate": Date(timeIntervalSince1970: TimeInterval(idx2))
        ])
      }

      // Commit the write transaction
      // to make this data available to other threads
      try! realm.commitWrite()
    }
  }
}