CONTACT US

LIKE

SHARE

FOLLOW

What is Realm?

Realm is a cross-platform mobile database designed specifically for mobile applications. It's lightweight and very simple to integrate in your project. Realm is built to be better and faster than his competitors SQLite and Core Data, easy to use and everything you need will be accomplished in just a couple of lines of code.

 

Simple saving. Fast queries. Save weeks of development time.

Realm Mobile Database is the best alternative to SQLite and Core Data. Thanks to its zero-copy design, Realm Mobile Database is much faster than an ORM, and often faster than raw SQLite. Get started in minutes, not hours. Realm is the best choice for your mobile database.

 

The perfect backend for the next generation of reactive mobile apps

The Realm Mobile Platform delivers automatic and seamless realtime data sync and powerful event handling between server and devices. You never need to think about networking code again.

The Realm Mobile Database is cross-platform, supporting both iOS and Android, and the Realm Object Server is ready to run on your servers or on your favorite cloud.

    Over 1 billion users rely on Realm

 

Trusted by Fortune 500 mainstays, innovative startups, and #1‑ranked app store successes, Realm is built into apps used by hundreds of millions of people every day.

How it works?

The Realm Mobile Platform combines the new Realm Object Server with our popular Realm Mobile Database.

  • Realm Sync Engine
    • Automatic two-way data synchronization and conflict resolution.

  • Realm Object Store
    • Persist and manage data as objects mirrored on mobile devices.

  • Dashboard
    • Monitor and manage your entire system at a glance.

  • Realm Event Framework
    • Trigger server-side events in response to data changes.

  • Realm Authentication System
    • Identify users with prebuilt mechanism or use your own.

  • Realm Access Control
    • Grant users the permissions they need for reading and writing data.

  • Realm Mobile Database
    • Embedded object database for mobile apps. Realm Mobile Platform extensions allow synchronization of live objects with Realm Object Server.

    • Sync available for Realm Java, Realm Objective‑C & Realm Swift. Coming soon for Realm React Native & Realm Xamarin.

 

How can you build better apps, faster?

 

  •   Realtime collaboration

    • Create realtime collaboration experiences, similar to Google Docs.

  • Two-way data sync

    • Realtime data synchronization with automatic conflict resolution.

  • Data push

    • Update client databases effortlessly with automated data push.

  • Messaging

    • Share text, images, maps, or custom data. No server work needed.

  • API bridge

    • Easily connect your mobile apps to existing system and APIs.

  • Presence

    • Know when users are online and track state.

 

Offline first

 

Data is stored locally in the Realm Mobile Database, which means that each device can fully function when offline, then re-sync when the network comes back. The Realm Mobile Platform handles the complexities of network state and conflict management, which means you never have to worry about server errors, JSON decoding, or conflict resolution.

 

On-premises or public cloud

Realm Object Server can be deployed on-premises or in the public cloud (like AWS, Azure, and other popular options). Integrate existing infrastructure with Realm Object Server to connect current and legacy systems to your mobile apps.

 

Build reactive apps

Realm objects are always live, which means that they always have the latest data. Subscribe to notifications to get updates when data changes, then update your UI. Your app will never be out of date again.

 

iOS Swift 3 Implementation Tutorial

 

  1. Install CocoaPods 0.39.0 or later.

  2. Run pod repo update to make CocoaPods aware of the latest available Realm versions.

  3. In your Podfile, add use_frameworks! and pod 'RealmSwift' to your main and test targets.

  4. If using Xcode 8, paste the following at the bottom of your Podfile, updating the Swift version if necessary:

platform :ios, ‘9.0’
use_frameworks!

source 'https://github.com/CocoaPods/Specs.git'

target 'MyApp' do
  pod 'RealmSwift'
end

post_install do |installer|
    installer.pods_project.targets.each do |target|
        target.build_configurations.each do |config|
            config.build_settings['SWIFT_VERSION'] = '3.0'
        end
    end
end

For tutorial demo purpose I've created a simple class named Person that represent object that will be saved on the realm database. In Realm you define your model classes by subclassing Object and adding properties to be managed. You then instantiate and use your custom subclasses instead of using the Object class directly.

Realm supports the following property types: Bool, Int8, Int16, Int32, Int64, Double, Float, String, NSDate, and NSData.

All property types except for List and RealmOptional must be declared as dynamic var. List and RealmOptional properties must be declared as non-dynamic let properties. Swift lazy properties are not allowed (check more).

For each of your model you can define a primary key. Declaring a primary key allows objects to be looked up and updated efficiently and enforces uniqueness for each value. Once an object with a primary key is added to a Realm, the primary key cannot be changed.

Also you can set the indexedProperties to set which properties in your model should be indexed. Indexing a property will greatly speed up queries where the property is compared for equality (i.e. the = and IN operators), at the cost of slower insertions.

import RealmSwift

class Person: Object {
    
    private(set) dynamic var id = 0
    private(set) dynamic var name = ""
    private(set) dynamic var email = ""
    
    /**
     Override Object.primaryKey() to set the model’s primary key. Declaring a primary key allows objects to be looked up and updated efficiently and enforces uniqueness for each value.
     */
    override static func primaryKey() -> String? {
        return "id"
    }
    
    convenience init(id: Int, name: String, email: String) {
        self.init()
        
        self.id = id
        self.name = name
        self.email = email
    }
}

Also, we need a RealmManager class to manage the realm operations, like delete, save, get and so on. For a brief presentation, I've added only the following three methods:

import RealmSwift

class RealmManager {
    
    let realm = try! Realm()
    
    /**
     Delete local database
     */
    func deleteDatabase() {
        try! realm.write({
            realm.deleteAll()
        })
    }
    
    /**
     Save array of objects to database
     */
    func saveObjects(objs: [Object]) {
        try! realm.write({
            // If update = true, objects that are already in the Realm will be 
            // updated instead of added a new.
            realm.add(objs, update: true)
        })
    }
    
    /**
     Returs an array as Results?
     */
    func getObjects(type: Object.Type) -> Results? {
        return realm.objects(type)
    }
}

You can notice that when we save in the realm database, we don't need to specify the object type, but when we retrieve the objects we need to specify the object meta type that we want to be retrieved.  

 

In Swift, the meta type of a type can be found by calling .self on a type. The returned type can either be a Class meta-type, a Struct meta-type or a Protocol meta-type. In our case, the object returned from calling Person.self is the Swift metaType of Person class.

 

On the TestClass is generated an array of Person that will be saved on the realm database. Certainly you can save objects individually and then get them individually, but on this demo scenario I chose to save and get objects as a list.

class TestClass {
    
    let realm = RealmManager()
    
    var persons = [Person]()
    
    func testAll() {
        addTestPersons()
        
        // save persons array to database
        realm.saveObjects(objs: persons)
        
        // get persons array from database
        getObjects()
    }
    
    func addTestPersons() {
        for index in 0...9 {
            let newPerson = Person(id: index, name: "Name\(index)", email: "p\(index)@gmail.com")
            persons.append(newPerson)
        }
    }
    
    func getObjects() {
        if let objects = realm.getObjects(type: Person.self) {
            for element in objects {
                if let person = element as? Person {
                    // Do whatever you like with 'person' object
                    print("\(person.name), \(person.id), \(person.email)")
                }
            }
        }
    }
}

When we get all objects of Person type, we will obtain an array of Results<Object>

Type. Next we can loop through each element of array using optional binding to recreate the Person object or we can directly downcast to to Person type using as! Swift operator. In this scenario I only printed the result on Xcode console, but you can do whatever you want with the Person object, like to recreate the persons array to be shown in a table view.

Name0, 0, p0@gmail.com
Name1, 1, p1@gmail.com
Name2, 2, p2@gmail.com
Name3, 3, p3@gmail.com
Name4, 4, p4@gmail.com
Name5, 5, p5@gmail.com
Name6, 6, p6@gmail.com
Name7, 7, p7@gmail.com
Name8, 8, p8@gmail.com
Name9, 9, p9@gmail.com

Impressions

                                                                          

References

You can checkout more about Realm on the official page https://realm.io/ and https://realm.io/docs/.

 
 

Ready to make it happen?

Drop us a line. We’d love to hear from you and see how we can help in solving your digital challenges. As one of the best software outsourcing companies in Romania, Eastern Europe, Europe and the world really, we are sure we can ASSIST.

GET IN TOUCH