Classes

RLMArray is the container type in Realm used to define to-many relationships.

Unlike an NSArray, RLMArrays hold a single type, specified by the objectClassName property. This is referred to in these docs as the “type” of the array.

When declaring an RLMArray property, the type must be marked as conforming to a protocol by the same name as the objects it should contain (see the RLM_ARRAY_TYPE macro). In addition, the property can be declared using Objective-C generics for better compile-time type safety.

RLM_ARRAY_TYPE(ObjectType)
...
@property RLMArray<ObjectType *><ObjectType> *arrayOfObjectTypes;

RLMArrays can be queried with the same predicates as RLMObject and RLMResults.

RLMArrays cannot be created directly. RLMArray properties on RLMObjects are lazily created when accessed, or can be obtained by querying a Realm.

Key-Value Observing

RLMArray supports array key-value observing on RLMArray properties on RLMObject subclasses, and the invalidated property on RLMArray instances themselves is key-value observing compliant when the RLMArray is attached to a managed RLMObject (RLMArrays on unmanaged RLMObjects will never become invalidated).

Because RLMArrays are attached to the object which they are a property of, they do not require using the mutable collection proxy objects from -mutableArrayValueForKey: or KVC-compatible mutation methods on the containing object. Instead, you can call the mutation methods on the RLMArray directly.

An RLMSortDescriptor stores a property name and a sort order for use with sortedResultsUsingDescriptors:. It is similar to NSSortDescriptor, but supports only the subset of functionality which can be efficiently run by Realm’s query engine.

RLMSortDescriptor instances are immutable.

A RLMCollectionChange object encapsulates information about changes to collections that are reported by Realm notifications.

RLMCollectionChange is passed to the notification blocks registered with -addNotificationBlock on RLMArray and RLMResults, and reports what rows in the collection changed since the last time the notification block was called.

The change information is available in two formats: a simple array of row indices in the collection for each type of change, and an array of index paths in a requested section suitable for passing directly to UITableView‘s batch update methods. A complete example of updating a UITableView named tv:

[tv beginUpdates];
[tv deleteRowsAtIndexPaths:[changes deletionsInSection:0] withRowAnimation:UITableViewRowAnimationAutomatic];
[tv insertRowsAtIndexPaths:[changes insertionsInSection:0] withRowAnimation:UITableViewRowAnimationAutomatic];
[tv reloadRowsAtIndexPaths:[changes modificationsInSection:0] withRowAnimation:UITableViewRowAnimationAutomatic];
[tv endUpdates];

All of the arrays in an RLMCollectionChange are always sorted in ascending order.

RLMMigration instances encapsulate information intended to facilitate a schema migration.

A RLMMigration instance is passed into a user-defined RLMMigrationBlock block when updating the version of a Realm. This instance provides access to the old and new database schemas, the objects in the Realm, and provides functionality for modifying the Realm during the migration.

RLMObject is a base class for model objects representing data stored in Realms.

Define your model classes by subclassing RLMObject and adding properties to be managed. Then instantiate and use your custom subclasses instead of using the RLMObject class directly.

// Dog.h
@interface Dog : RLMObject
@property NSString *name;
@property BOOL      adopted;
@end

// Dog.m
@implementation Dog
@end //none needed

Supported property types

• NSString
• NSInteger, int, long, float, and double
• BOOL or bool
• NSDate
• NSData
• NSNumber<X>, where X is one of RLMInt, RLMFloat, RLMDouble or RLMBool, for optional number properties
• RLMObject subclasses, to model many-to-one relationships.
• RLMArray<X>, where X is an RLMObject subclass, to model many-to-many relationships.

Querying

You can initiate queries directly via the class methods: allObjects, objectsWhere:, and objectsWithPredicate:. These methods allow you to easily query a custom subclass for instances of that class in the default Realm.

To search in a Realm other than the default Realm, use the allObjectsInRealm:, objectsInRealm:where:, and objectsInRealm:withPredicate: class methods.

Relationships

See our Cocoa guide for more details.

Key-Value Observing

All RLMObject properties (including properties you create in subclasses) are Key-Value Observing compliant, except for realm and objectSchema.

Keep the following tips in mind when observing Realm objects:

1. Unlike NSMutableArray properties, RLMArray properties do not require using the proxy object returned from -mutableArrayValueForKey:, or defining KVC mutation methods on the containing class. You can simply call methods on the RLMArray directly; any changes will be automatically observed by the containing object.
2. Unmanaged RLMObject instances cannot be added to a Realm while they have any observed properties.
3. Modifying managed RLMObjects within -observeValueForKeyPath:ofObject:change:context: is not recommended. Properties may change even when the Realm is not in a write transaction (for example, when -[RLMRealm refresh] is called after changes are made on a different thread), and notifications sent prior to the change being applied (when NSKeyValueObservingOptionPrior is used) may be sent at times when you cannot begin a write transaction.

Information about a specific property which changed in an RLMObject change notification.

This class represents Realm model object schemas.

When using Realm, RLMObjectSchema instances allow performing migrations and introspecting the database’s schema.

Object schemas map to tables in the core database.

RLMProperty instances represent properties managed by a Realm in the context of an object schema. Such properties may be persisted to a Realm file or computed from other data from the Realm.

When using Realm, RLMProperty instances allow performing migrations and introspecting the database’s schema.

These property instances map to columns in the core database.

An RLMPropertyDescriptor instance represents a specific property on a given class.

An RLMRealm instance (also referred to as a Realm) represents a Realm database.

Realms can either be stored on disk (see +[RLMRealm realmWithURL:]) or in memory (see RLMRealmConfiguration).

RLMRealm instances are cached internally, and constructing equivalent RLMRealm objects (for example, by using the same path or identifier) multiple times on a single thread within a single iteration of the run loop will normally return the same RLMRealm object.

If you specifically want to ensure an RLMRealm instance is destroyed (for example, if you wish to open a Realm, check some property, and then possibly delete the Realm file and re-open it), place the code which uses the Realm within an @autoreleasepool {} and ensure you have no other strong references to it.

A token which is returned from methods which subscribe to changes to a Realm.

Change subscriptions in Realm return an RLMNotificationToken instance, which can be used to unsubscribe from the changes. You must store a strong reference to the token for as long as you want to continue to receive notifications. When you wish to stop, call the -invalidate method. Notifications are also stopped if the token is deallocated.

An RLMRealmConfiguration instance describes the different options used to create an instance of a Realm.

RLMRealmConfiguration instances are just plain NSObjects. Unlike RLMRealms and RLMObjects, they can be freely shared between threads as long as you do not mutate them.

Creating configuration objects 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 object for each distinct configuration rather than creating a new object each time you open a Realm.

RLMSchema instances represent collections of model object schemas managed by a Realm.

When using Realm, RLMSchema instances allow performing migrations and introspecting the database’s schema.

Schemas map to collections of tables in the core database.

A configuration object representing configuration state for a Realm which is intended to sync with a Realm Object Server.

A singleton manager which serves as a central point for sync-related configuration.

A token object corresponding to a progress notification block on a session object.

To stop notifications manually, call -invalidate on it. Notifications should be stopped before the token goes out of scope or is destroyed.

An object encapsulating a Realm Object Server session. Sessions represent the communication between the client (and a local Realm file on disk), and the server (and a remote Realm at a given URL stored on a Realm Object Server).

Sessions are always created by the SDK and vended out through various APIs. The lifespans of sessions associated with Realms are managed automatically. Session objects can be accessed from any thread.

An opaque token returned as part of certain errors. It can be passed into certain APIs to perform certain actions.

RLMSyncSubscription represents a subscription to a set of objects in a synced Realm.

When Query-based sync is enabled for a synced Realm, the only objects that the server synchronizes to the client are those that match a sync subscription registered by that client. A subscription consists of of a query (represented by an RLMResults) and an optional name.

The state of the subscription can be observed using Key-Value Observing on the state property.

Subscriptions are created using -[RLMResults subscribe] or -[RLMResults subscribeWithName:].

RLMResults is an auto-updating container type in Realm returned from object queries. It represents the results of the query in the form of a collection of objects.

RLMResults can be queried using the same predicates as RLMObject and RLMArray, and you can chain queries to further filter results.

RLMResults always reflect the current state of the Realm on the current thread, including during write transactions on the current thread. The one exception to this is when using for...in fast enumeration, which will always enumerate over the objects which matched the query when the enumeration is begun, even if some of them are deleted or modified to be excluded by the filter during the enumeration.

RLMResults are lazily evaluated the first time they are accessed; they only run queries when the result of the query is requested. This means that chaining several temporary RLMResults to sort and filter your data does not perform any extra work processing the intermediate state.

Once the results have been evaluated or a notification block has been added, the results are eagerly kept up-to-date, with the work done to keep them up-to-date done on a background thread whenever possible.

RLMResults cannot be directly instantiated.

RLMLinkingObjects is an auto-updating container type. It represents a collection of objects that link to its parent object.

For more information, please see the Inverse Relationships section in the documentation.

A RLMSyncUser instance represents a single Realm Object Server user account.

A user may have one or more credentials associated with it. These credentials uniquely identify the user to the authentication provider, and are used to sign into a Realm Object Server user account.

Note that user objects are only vended out via SDK APIs, and cannot be directly initialized. User objects can be accessed from any thread.

A data object representing a user account associated with a user.

A data object representing information about a user that was retrieved from a user lookup call.

An object intended to be passed between threads containing a thread-safe reference to its thread-confined object.

To resolve a thread-safe reference on a target Realm on a different thread, pass to -[RLMRealm resolveThreadSafeReference:].

Opaque credentials representing a specific Realm Object Server user.

A permission which can be applied to a Realm, Class, or specific Object.

Permissions are applied by adding the permission to the RLMRealmPermission singleton object, the RLMClassPermission object for the desired class, or to a user-defined RLMArray property on a specific Object instance. The meaning of each of the properties of RLMPermission depend on what the permission is applied to, and so are left undocumented here. See RLMRealmPrivileges, RLMClassPrivileges, and RLMObjectPrivileges for details about what each of the properties mean when applied to that type.

A Role within the permissions system.

A Role consists of a name for the role and a list of users which are members of the role. Roles are granted privileges on Realms, Classes and Objects, and in turn grant those privileges to all users which are members of the role.

A role named everyone is automatically created in new Realms, and all new users which connect to the Realm are automatically added to it. Any other roles you wish to use are managed as normal Realm objects.

A representation of a sync user within the permissions system.

RLMPermissionUser objects are created automatically for each sync user which connects to a Realm, and can also be created manually if you wish to grant permissions to a user which has not yet connected to this Realm.

A singleton object which describes Realm-wide permissions.

An object of this type is automatically created in the Realm for you, and more objects cannot be created manually. Call +[RLMRealmPermission objectInRealm:] to obtain the instance for a specific Realm.

See RLMRealmPrivileges for the meaning of permissions applied to a Realm.

An object which describes class-wide permissions.

An instance of this object is automatically created in the Realm for class in your schema, and should not be created manually. Call +[RLMClassPermission objectInRealm:forClassNamed:] or +[RLMClassPermission objectInRealm:forClass:] to obtain the existing instance, or query RLMClassPermission as normal.

A value representing a permission granted to the specified user(s) to access the specified Realm(s).

RLMSyncPermission is immutable and can be accessed from any thread.

See https://realm.io/docs/realm-object-server/#permissions for general documentation.