Realm

The Schema used by the Realm.

The Configuration value that was used to create the Realm instance.

Indicates if the Realm contains any objects.

Obtains an instance of the default Realm.

The default Realm is persisted as default.realm under the Documents directory of your Application on iOS, and in your application’s Application Support directory on OS X.

The default Realm is created using the default Configuration, which can be changed by setting the Realm.Configuration.defaultConfiguration property to a new value.

Obtains a Realm instance with the given configuration.

Obtains a Realm instance persisted at a specified file URL.

Asynchronously open a Realm and deliver it to a block on the given queue.

Opening a Realm asynchronously will perform all work needed to get the Realm to a usable state (such as running potentially time-consuming migrations) on a background thread before dispatching to the given queue. In addition, synchronized Realms wait for all remote content available at the time the operation began to be downloaded and available locally.

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

If the block throws an error, the transaction will be canceled and any changes made before the error will be rolled back.

Only one write transaction can be open at a time for each Realm file. 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 write from Realm instances for the same Realm file in other threads or other processes will block until the current write transaction completes or is cancelled.

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

Begins a write transaction on the Realm.

Only one write transaction can be open at a time for each Realm file. 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 for the same Realm file in other threads or other processes will block until the current write transaction completes or is cancelled.

Before beginning the write transaction, beginWrite updates the Realm instance to the latest Realm version, as if refresh() had been 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 participating in the write transaction is kept alive until the write transaction is committed.

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

After saving the changes and completing the write transaction, all notification blocks registered on this specific Realm instance are called synchronously. Notification blocks for Realm instances on other threads and blocks registered for any Realm collection (including those on the current thread) are scheduled to be called synchronously.

You can skip notifiying specific notification blocks about the changes made in this write transaction by passing in their associated notification tokens. This is primarily useful when the write transaction is saving changes already made in the UI and you do not want to have the notification block attempt to re-apply the same changes.

The tokens passed to this function must be for notifications for this Realm which were added on the same thread as the write transaction is being performed on. Notifications for different threads cannot be skipped using this method.

Reverts all writes made in the current write transaction and ends 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 becoming unmanaged.

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 isInvalidated, but re-running the query which provided oldObject will once again return the valid object.

KVO observers on any objects which were modified during the transaction will be notified about the change back to their initial values, but no other notifcations are produced by a cancelled write transaction.

Indicates whether the Realm is currently in a write transaction.

Adds or updates an existing object into the Realm.

Only pass true to update if the object has a primary key. If no object exists in the Realm 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 are already being managed by a different Realm an error will be thrown. Instead, use one of the create functions to insert a copy of a managed object into a different Realm.

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

Adds or updates all the objects in a collection into the Realm.

Creates or updates a Realm object with a given value, adding it to the Realm and returning it.

You may only pass true to update if the object has a primary key. If no object exists in the Realm with the same primary key value, the object is inserted. Otherwise, the existing object is updated with any changed values.

The value argument can be a Realm object, a key-value coding compliant object, an array or dictionary returned from the methods in NSJSONSerialization, or an Array containing one element for each managed property. Do not pass in a LinkingObjects instance, either by itself or as a member of a collection.

If the object is being created, all required properties that were not defined with default values must be given initial values through the value argument. Otherwise, an Objective-C exception will be thrown.

If the object is being updated, all properties defined in its schema will be set by copying from value using key-value coding. If the value argument does not respond to value(forKey:) for a given property name (or getter name, if defined), that value will remain untouched. Nullable properties on the object can be set to nil by using NSNull as the updated value, or (if you are passing in an instance of an Object subclass) setting the corresponding property on value to nil.

If the value argument is an array, all properties must be present, valid and in the same order as the properties defined in the model.

Deletes an object from the Realm. Once the object is deleted it is considered invalidated.

Deletes zero or more objects from the Realm.

Do not pass in a slice to a Results or any other auto-updating Realm collection type (for example, the type returned by the Swift suffix(_:) standard library method). Instead, make a copy of the objects to delete using Array(), and pass that instead. Directly passing in a view into an auto-updating collection may result in ‘index out of bounds’ exceptions being thrown.

Deletes all objects from the Realm.

Returns all objects of the given type stored in the Realm.

Retrieves the single instance of a given object type with the given primary key from the Realm.

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

Adds a notification handler for changes made to this Realm, and returns a notification token.

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

Handler blocks are called on the same thread that they were added on, and may 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 will normally only be the main thread.

Notifications can’t be delivered as long as the run loop 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 be sent to the block. To stop receiving updates, call invalidate() on the token.

Set this property to true to automatically update this Realm 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 data.

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 property 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 automatic refreshing is enabled.

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

Defaults to true.

Updates the Realm and outstanding objects managed by the Realm to point to the most recent data.

Invalidates all Objects, Results, LinkingObjects, and Lists managed by the 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 instance on the current thread are invalidated. Objects and Arrays cannot be used. Results will become empty. 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 may not be called on a read-only Realm.

Writes a compacted and optionally encrypted copy of the Realm to the given local URL.

The destination file cannot already exist.

Note that if this method is called from within a write transaction, the current data is written, not the data from the point when the previous write transaction was committed.

Struct that describes the error codes within the Realm error domain. The values can be used to catch a variety of recoverable errors, especially those happening when initializing a Realm instance.

let realm: Realm?
do {
    realm = try Realm()
} catch Realm.Error.incompatibleLockFile {
    print("Realm Browser app may be attached to Realm on device?")
}

Performs the given Realm configuration’s migration block on a Realm at the given path.

This method is called automatically when opening a Realm for the first time and does not need to be called explicitly. You can choose to call this method to control exactly when and how migrations are performed.

Returns whether two Realm instances are equal.

A notification indicating that changes were made to a Realm.

A Configuration instance describes the different options used to create an instance of a Realm.

Configuration instances are just plain Swift structs. Unlike Realms and Objects, they can be freely shared between threads as long as you do not mutate them.

Creating configuration values for class subsets (by setting the objectClasses property) can be expensive. Because of this, you will normally want to cache and reuse a single configuration value for each distinct configuration rather than creating a new value each time you open a Realm.

If the Realm is a partially synchronized Realm, fetch and synchronize the objects of a given object type that match the given query (in string format).

The results will be returned asynchronously in the callback. Use Results.observe(_:) to be notified to changes to the set of synchronized objects.

-warning: Partial synchronization is a tech preview. Its APIs are subject to change.

Get the SyncSession used by this Realm. Will be nil if this is not a synchronized Realm.

Returns the computed privileges which the current user has for this Realm.

This combines all privileges granted on the Realm by all Roles which the current User is a member of into the final privileges which will be enforced by the server.

The privilege calculation is done locally using cached data, and inherently may be stale. It is possible that this method may indicate that an operation is permitted but the server will still reject it if permission is revoked before the changes have been integrated on the server.

Non-synchronized and fully-synchronized Realms always have permission to perform all operations.

Returns the computed privileges which the current user has for the given object.

This combines all privileges granted on the object by all Roles which the current User is a member of into the final privileges which will be enforced by the server.

The privilege calculation is done locally using cached data, and inherently may be stale. It is possible that this method may indicate that an operation is permitted but the server will still reject it if permission is revoked before the changes have been integrated on the server.

Non-synchronized and fully-synchronized Realms always have permission to perform all operations.

The object must be a valid object managed by this Realm. Passing in an invalidated object, an unmanaged object, or an object managed by a different Realm will throw an exception.

Returns the computed privileges which the current user has for the given class.

This combines all privileges granted on the class by all Roles which the current User is a member of into the final privileges which will be enforced by the server.

The privilege calculation is done locally using cached data, and inherently may be stale. It is possible that this method may indicate that an operation is permitted but the server will still reject it if permission is revoked before the changes have been integrated on the server.

Non-synchronized and fully-synchronized Realms always have permission to perform all operations.

Returns the computed privileges which the current user has for the named class.

This combines all privileges granted on the class by all Roles which the current User is a member of into the final privileges which will be enforced by the server.

The privilege calculation is done locally using cached data, and inherently may be stale. It is possible that this method may indicate that an operation is permitted but the server will still reject it if permission is revoked before the changes have been integrated on the server.

Non-synchronized and fully-synchronized Realms always have permission to perform all operations.

Returns the class-wide permissions for the given class.

Returns the class-wide permissions for the named class.

Returns the Realm-wide permissions.

Returns this list of the query-based sync subscriptions made for this Realm.

This list includes all subscriptions which are currently in the states .pending, .created, and .error. Newly created subscriptions which are still in the .creating state are not included, and calling this immediately after calling Results.subscribe() will typically not include that subscription. Similarly, because unsubscription happens asynchronously, this may continue to include subscriptions after SyncSubscription.unsubscribe() is called on them.

Returns the named query-based sync subscription, if it exists.

Subscriptions are created asynchronously, so calling this immediately after calling Results.subscribe(named:)will typically returnnil. Only subscriptions which are currently in the states.pending,.created, and.error` can be retrieved with this method.

Returns the same object as the one referenced when the ThreadSafeReference was first created, but resolved for the current Realm for this thread. Returns nil if this object was deleted after the reference was created.