Classes

The following classes are available globally.

  • A Realm instance (also referred to as a Realm) represents a Realm database.

    Realms can either be stored on disk (see init(path:)) or in memory (see Configuration).

    Realm instances are cached internally, and constructing equivalent Realm objects (for example, by using the same path or identifier) produces limited overhead.

    If you specifically want to ensure a Realm 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.

    Warning

    Realm instances are not thread safe and cannot be shared across threads or dispatch queues. You must construct a new instance for each thread in which a Realm will be accessed. For dispatch queues, this means that you must construct a new instance in each block which is dispatched, as a queue is not guaranteed to run all of its blocks on the same thread.
    See more

    Declaration

    Swift

    public final class Realm
    Show on GitHub

  • LinkingObjects is an auto-updating container type. It represents zero or more objects that are linked to its owning model object through a property relationship.

    LinkingObjects can be queried with the same predicates as List<T> and Results<T>.

    LinkingObjects always reflects 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 enumeration, which will always enumerate over the linking objects that were present when the enumeration is begun, even if some of them are deleted or modified to no longer link to the target object during the enumeration.

    LinkingObjects can only be used as a property on Object models. Properties of this type must be declared as let and cannot be dynamic.

    See more

    Declaration

    Swift

    public final class LinkingObjects<T: Object>: LinkingObjectsBase
    Show on GitHub

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

    Like Swift’s Array, List is a generic type that is parameterized on the type of Object it stores.

    Unlike Swift’s native collections, Lists are reference types, and are only immutable if the Realm that manages them is opened as read-only.

    Lists can be filtered and sorted with the same predicates as Results<T>.

    Properties of List type defined on Object subclasses must be declared as let and cannot be dynamic.

    See more

    Declaration

    Swift

    public final class List<T: Object>: ListBase
    Show on GitHub

  • Object is a class used to define Realm model objects.

    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.

    class Dog: Object {
    @objc dynamic var name: String = ""
    @objc dynamic var adopted: Bool = false
    let siblings = List<Dog>()
}

    Supported property types

    • String, NSString
    • Int
    • Int8, Int16, Int32, Int64
    • Float
    • Double
    • Bool
    • Date, NSDate
    • Data, NSData
    • RealmOptional<T> for optional numeric properties
    • Object subclasses, to model many-to-one relationships
    • List<T>, to model many-to-many relationships

    String, NSString, Date, NSDate, Data, NSData and Object subclass properties can be declared as optional. Int, Int8, Int16, Int32, Int64, Float, Double, Bool, and List properties cannot. To store an optional number, use RealmOptional<Int>, RealmOptional<Float>, RealmOptional<Double>, or RealmOptional<Bool> instead, which wraps an optional numeric value.

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

    Note that none of the restrictions listed above apply to properties that are configured to be ignored by Realm.

    Querying

    You can retrieve all objects of a given type from a Realm by calling the objects(_:) instance method.

    Relationships

    See our Cocoa guide for more details.

    See more

    Declaration

    Swift

    open class Object: RLMObjectBase, ThreadConfined
    Show on GitHub

  • A RealmOptional instance represents an optional value for types that can’t be directly declared as dynamic in Swift, such as Int, Float, Double, and Bool.

    To change the underlying value stored by a RealmOptional instance, mutate the instance’s value property.

    See more

    Declaration

    Swift

    public final class RealmOptional<T: RealmOptionalType>: RLMOptionalBase
    Show on GitHub

AddableType

  • Results is an auto-updating container type in Realm returned from object queries.

    Results can be queried with the same predicates as List<T>, and you can chain queries to further filter query results.

    Results 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 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.

    Results 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 Results to sort and filter your data does not perform any unnecessary 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.

    Results instances cannot be directly instantiated.

    See more

    Declaration

    Swift

    public final class Results<T: Object>: NSObject, NSFastEnumeration
    Show on GitHub

  • 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 Realm.resolve(_:).

    Warning

    A ThreadSafeReference object must be resolved at most once. Failing to resolve a ThreadSafeReference will result in the source version of the Realm being pinned until the reference is deallocated.

    Note

    Prefer short-lived ThreadSafeReferences as the data for the version of the source Realm will be retained until all references have been resolved or deallocated.

    See

    ThreadConfined

    See

    Realm.resolve(_:)

    See more

    Declaration

    Swift

    public class ThreadSafeReference<Confined: ThreadConfined>
    Show on GitHub