Realm

Path to the file where this Realm is persisted.

Indicates if this Realm was opened in read-only mode.

The Schema used by this realm.

Returns the Configuration that was used to create this Realm instance.

Indicates if this Realm contains any objects.

Obtains a Realm instance with the default Realm configuration, which can be changed by setting Realm.Configuration.defaultConfiguration.

Obtains a Realm instance with the given configuration.

Obtains a Realm instance persisted at the specified file path.

Obtains a Realm instance persisted at the specified file URL.

Performs actions contained within the given block inside a write transaction.

Write transactions cannot be nested, and trying to execute a write transaction on a Realm which is already in a write transaction will throw an exception. Calls to write from Realm instances in other threads will block until the current write transaction completes.

Before executing the write transaction, write updates the Realm to the latest Realm version, as if refresh() was called, and generates notifications if applicable. This has no effect if the Realm was already up to date.

Begins a write transaction in a Realm.

Only one write transaction can be open at a time. Write transactions cannot be nested, and trying to begin a write transaction on a Realm which is already in a write transaction will throw an exception. Calls to beginWrite from Realm instances in other threads will block until the current write transaction completes.

Before beginning the write transaction, beginWrite updates the Realm to the latest Realm version, as if refresh() was called, and generates notifications if applicable. This has no effect if the Realm was already up to date.

It is rarely a good idea to have write transactions span multiple cycles of the run loop, but if you do wish to do so you will need to ensure that the Realm in the write transaction is kept alive until the write transaction is committed.

Commits all writes operations in the current write transaction, and ends the transaction.

Calling this when not in a write transaction will throw an exception.

Reverts all writes made in the current write transaction and end the transaction.

This rolls back all objects in the Realm to the state they were in at the beginning of the write transaction, and then ends the transaction.

This restores the data for deleted objects, but does not revive invalidated object instances. Any Objects which were added to the Realm will be invalidated rather than switching back to standalone objects. Given the following code:

let oldObject = objects(ObjectType).first!
let newObject = ObjectType()

realm.beginWrite()
realm.add(newObject)
realm.delete(oldObject)
realm.cancelWrite()

Both oldObject and newObject will return true for invalidated, but re-running the query which provided oldObject will once again return the valid object.

Calling this when not in a write transaction will throw an exception.

Indicates if this Realm is currently in a write transaction.

Adds or updates an object to be persisted it in this Realm.

When ‘update’ is ‘true’, the object must have a primary key. If no objects exist in the Realm instance with the same primary key value, the object is inserted. Otherwise, the existing object is updated with any changed values.

When added, all (child) relationships referenced by this object will also be added to the Realm if they are not already in it. If the object or any related objects already belong to a different Realm an exception will be thrown. Use one of the create functions to insert a copy of a persisted object into a different Realm.

The object to be added must be valid and cannot have been previously deleted from a Realm (i.e. invalidated must be false).

Adds or updates objects in the given sequence to be persisted it in this Realm.

Create an Object with the given value.

Creates or updates an instance of this object and adds it to the Realm populating the object with the given value.

When ‘update’ is ‘true’, the object must have a primary key. If no objects exist in the Realm instance with the same primary key value, the object is inserted. Otherwise, the existing object is updated with any changed values.

Deletes the given object from this Realm.

Deletes the given objects from this Realm.

Deletes all objects from this Realm.

Returns all objects of the given type in the Realm.

Get an object with the given primary key.

Returns nil if no object exists with the given primary key.

This method requires that primaryKey() be overridden on the given subclass.

Add a notification handler for changes in this Realm.

Notification handlers are called after each write transaction is committed, independent from the thread or process.

The block is called on the same thread as it was added on, and can only be added on threads which are currently within a run loop. Unless you are specifically creating and running a run loop on a background thread, this normally will only be the main thread.

Notifications can’t be delivered as long as the runloop is blocked by other activity. When notifications can’t be delivered instantly, multiple notifications may be coalesced.

You must retain the returned token for as long as you want updates to continue to be sent to the block. To stop receiving updates, call stop() on the token.

Remove a previously registered notification handler using the token returned from addNotificationBlock(_:)

Whether this Realm automatically updates when changes happen in other threads.

If set to true (the default), changes made on other threads will be reflected in this Realm on the next cycle of the run loop after the changes are committed. If set to false, you must manually call refresh() on the Realm to update it to get the latest version.

Note that by default, background threads do not have an active run loop and you will need to manually call refresh() in order to update to the latest version, even if autorefresh is set to true.

Even with this enabled, you can still call refresh() at any time to update the Realm before the automatic refresh would occur.

Notifications are sent when a write transaction is committed whether or not this is enabled.

Disabling this on a Realm without any strong references to it will not have any effect, and it will switch back to YES the next time the Realm object is created. This is normally irrelevant as it means that there is nothing to refresh (as persisted Objects, Lists, and Results have strong references to the containing Realm), but it means that setting Realm().autorefresh = false in application(_:didFinishLaunchingWithOptions:) and only later storing Realm objects will not work.

Defaults to true.

Update a Realm and outstanding objects to point to the most recent data for this Realm.

Invalidate all Objects and Results read from this Realm.

A Realm holds a read lock on the version of the data accessed by it, so that changes made to the Realm on different threads do not modify or delete the data seen by this Realm. Calling this method releases the read lock, allowing the space used on disk to be reused by later write transactions rather than growing the file. This method should be called before performing long blocking operations on a background thread on which you previously read data from the Realm which you no longer need.

All Object, Results and List instances obtained from this Realm on the current thread are invalidated, and can not longer be used. The Realm itself remains valid, and a new read transaction is implicitly begun the next time data is read from the Realm.

Calling this method multiple times in a row without reading any data from the Realm, or before ever reading any data from the Realm is a no-op. This method cannot be called on a read-only Realm.

Write an encrypted and compacted copy of the Realm to the given path.

The destination file cannot already exist.

Note that if this is called from within a write transaction it writes the current data, and not data when the last write transaction was committed.

Write an encrypted and compacted copy of the Realm to the given local URL.

The destination file cannot already exist.

Note that if this is called from within a write transaction it writes the current data, and not data when the last write transaction was committed.

A Realm.Configuration is used to describe the different options used to create a Realm instance.

Realm.Configuration instances are just plain Swift structs, and unlike Realm and Objects can be freely shared between threads. Creating configuration objects for class subsets (by setting the objectTypes property) can be expensive, and so you will normally want to cache and reuse a single configuration object for each distinct configuration that you are using rather than creating a new one each time you open a Realm.

Returns a human-readable description of the configuration.