Type Aliases

PropertyType is an enum describing all property types supported in Realm models.

For more information, see Object Models and Schemas.

Primitive types

• Int
• Bool
• Float
• Double

Object types

• String
• Data
• Date
• Decimal128
• ObjectId

Relationships: Array (in Swift, List) and Object types

• Object
• Array

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

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 {
    @Persisted var name: String
    @Persisted var adopted: Bool
    @Persisted var siblings: List<Dog>
}

Supported property types

• String
• Int, Int8, Int16, Int32, Int64
• Float
• Double
• Bool
• Date
• Data
• Decimal128
• ObjectId
• UUID
• AnyRealmValue
• Any RawRepresentable enum whose raw type is a legal property type. Enums must explicitly be marked as conforming to PersistableEnum.
• Object subclasses, to model many-to-one relationships
• EmbeddedObject subclasses, to model owning one-to-one relationships

All of the types above may also be Optional, with the exception of AnyRealmValue. Object and EmbeddedObject subclasses must be Optional.

In addition to individual values, three different collection types are supported:

• List<Element>: an ordered mutable collection similar to Array.
• MutableSet<Element>: an unordered uniquing collection similar to Set.
• Map<String, Element>: an unordered key-value collection similar to Dictionary.

The Element type of collections may be any of the supported non-collection property types listed above. Collections themselves may not be Optional, but the values inside them may be, except for lists and sets of Object or EmbeddedObject subclasses.

Finally, LinkingObjects properties can be used to track which objects link to this one.

All properties which should be stored by Realm must be explicitly marked with @Persisted. Any properties not marked with @Persisted will be ignored entirely by Realm, and may be of any type.

Querying

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

Relationships

See our Swift guide for more details.

EmbeddedObject is a base class used to define embedded Realm model objects.

Embedded objects work similarly to normal objects, but are owned by a single parent Object (which itself may be embedded). Unlike normal top-level objects, embedded objects cannot be directly created in or added to a Realm. Instead, they can only be created as part of a parent object, or by assigning an unmanaged object to a parent object’s property. Embedded objects are automatically deleted when the parent object is deleted or when the parent is modified to no longer point at the embedded object, either by reassigning an Object property or by removing the embedded object from the List containing it.

Embedded objects can only ever have a single parent object which links to them, and attempting to link to an existing managed embedded object will throw an exception.

The property types supported on EmbeddedObject are the same as for Object, except for that embedded objects cannot link to top-level objects, so Object and List<Object> properties are not supported (EmbeddedObject and List<EmbeddedObject> are).

Embedded objects cannot have primary keys or indexed properties.

class Owner: Object {
    @Persisted var name: String
    @Persisted var dogs: List<Dog>
}
class Dog: EmbeddedObject {
    @Persisted var name: String
    @Persisted var adopted: Bool
    @Persisted(originProperty: "dogs") var owner: LinkingObjects<Owner>
}

A struct that represents the coordinates of a point formed by a latitude and a longitude value.

• Latitude ranges between -90 and 90 degrees, inclusive.
• Longitude ranges between -180 and 180 degrees, inclusive.

Values outside this ranges will return nil when trying to create a GeoPoint.

Persisting geo points in Realm is currently done using duck-typing, which means that any model class with a specific shape can be queried as though it contained a geographical location.

the following is required:

• A String property with the value of Point: @Persisted var type: String = "Point".
• A List containing a Longitude/Latitude pair: @Persisted private var coordinates: List<Double>.

The recommended approach is using an embedded object.

public class Location: EmbeddedObject {
  @Persisted private var coordinates: List<Double>
  @Persisted private var type: String = "Point"

  public var latitude: Double { return coordinates[1] }
  public var longitude: Double { return coordinates[0] }

  convenience init(_ latitude: Double, _ longitude: Double) {
      self.init()
      // Longitude comes first in the coordinates array of a GeoJson document
      coordinates.append(objectsIn: [longitude, latitude])
    }
  }

A class that represents a rectangle, that can be used in a geospatial geoWithinquery.

A class that represents a polygon, that can be used in a geospatial geoWithinquery.

A GeoPolygon describes a shape conformed of and outer Polygon, called outerRing, and 0 or more inner Polygons, called holes, which represents an unlimited number of internal holes inside the outer Polygon. A Polygon describes a shape conformed by at least three segments, where the last and the first GeoPoint must be the same to indicate a closed polygon (meaning you need at least 4 points to define a polygon). Inner holes in a GeoPolygon must be entirely inside the outer ring

A hole has the following restrictions:

• Holes may not cross, i.e. the boundary of a hole may not intersect both the interior and the exterior of any other hole.
• Holes may not share edges, i.e. if a hole contains and edge AB, the no other hole may contain it.
• Holes may share vertices, however no vertex may appear twice in a single hole.
• No hole may be empty.

• Only one nesting is allowed.

This structure is a helper to represent/convert a distance. It can be used in geospatial queries like those represented by a GeoCircle

A class that represents a circle, that can be used in a geospatial geoWithinquery.

The type of a migration block used to migrate a Realm.

An object class used during migrations.

A block type which provides both the old and new versions of an object in the Realm. Object properties can only be accessed using subscripting.

Migration instances encapsulate information intended to facilitate a schema migration.

A Migration instance is passed into a user-defined MigrationBlock 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.

The Id of the asynchronous transaction.

The type of a block to run for notification purposes when the data in a Realm is modified.

Logger is used for creating your own custom logging logic.

You can define your own logger creating an instance of Logger and define the log function which will be invoked whenever there is a log message.

let logger = Logger(level: .all) { level, message in
   print("Realm Log - \(level): \(message)")
}

Set this custom logger as you default logger using Logger.shared.

   Logger.shared = inMemoryLogger