Define a Realm Object Model - Swift SDK

Persisted Property Attributes

Declare model properties that you want to store to the database as @Persisted. This enables them to access the underlying database data.

When you declare any properties as @Persisted within a class, the other properties within that class are automatically ignored.

If you mix @Persisted and @objc dynamic property declarations within a class definition, any property attributes marked as @objc dynamic will be ignored.

Objective-C Dynamic Property Attributes

Declara propiedades dinámicas del modelo Realm en el tiempo de ejecución de Objective-C. Esto les permite acceder a los datos subyacentes de la base de datos.

Puedes:

• Utiliza @objc dynamic var para declarar propiedades individuales

• Utilice @objcMembers para declarar una clase. Luego, declare las propiedades individuales con dynamic var.

Use let to declare LinkingObjects, List, RealmOptional and RealmProperty. The Objective-C runtime cannot represent these generic properties.

// Task.h
@interface Task : RLMObject
@property NSString *description;
@end
// Define an RLMArray<Task> type
RLM_COLLECTION_TYPE(Task)
// User.h
// #include "Task.h"
@interface User : RLMObject
@property NSString *name;
// Use RLMArray<Task> to have a list of tasks
// Note the required double tag (<Task *><Task>)
@property RLMArray<Task *><Task> *tasks;
@end

Specify an Optional/Required Property

class Person: Object {
    // Required string property
    @Persisted var name = ""
    // Optional string property
    @Persisted var address: String?
    // Required numeric property
    @Persisted var ageYears = 0
    // Optional numeric property
    @Persisted var heightCm: Float?
}

@interface Person : RLMObject
// Required property - included in `requiredProperties`
// return value array
@property NSString *name;
// Optional string property - not included in `requiredProperties`
@property NSString *address;
// Required numeric property
@property int ageYears;
// Optional numeric properties use NSNumber tagged
// with RLMInt, RLMFloat, etc.
@property NSNumber<RLMFloat> *heightCm;
@end
@implementation Person
// Specify required pointer-type properties here.
// Implicitly required properties (such as properties
// of primitive types) do not need to be named here.
+ (NSArray<NSString *> *)requiredProperties {
    return @[@"name"];
}
@end

class Person: Object {
    // Required string property
    @objc dynamic var name = ""
    // Optional string property
    @objc dynamic var address: String?
    // Required numeric property
    @objc dynamic var ageYears = 0
    // Optional numeric property
    let heightCm = RealmProperty<Float?>()
}

Specify a Primary Key

Puede designar una propiedad como la llave primaria de su clase.

Primary keys allow you to efficiently find, update, and upsert objects.

Primary keys are subject to the following limitations:

• You can define only one primary key per object model.

• Primary key values must be unique across all instances of an object in a realm. Realm throws an error if you try to insert a duplicate primary key value.

• Los valores de la llave primaria son inmutables. Para cambiar el valor de la clave primaria de un objeto, se debe borrar el objeto original e insertar uno nuevo con un valor de clave primaria diferente.

• Los objetos incrustados no pueden definir una clave principal.

class Project: Object {
    @Persisted(primaryKey: true) var id = 0
    @Persisted var name = ""
}

@interface Project : RLMObject
@property NSInteger id; // Intended primary key
@property NSString *name;
@end
@implementation Project
// Return the name of the primary key property
+ (NSString *)primaryKey {
    return @"id";
}
@end

class Project: Object {
    @objc dynamic var id = 0
    @objc dynamic var name = ""
    // Return the name of the primary key property
    override static func primaryKey() -> String? {
        return "id"
    }
}

Indexar una propiedad

Puedes crear un índice en una propiedad específica de tu modelo. Los índices aceleran las consultas mediante los operadores de igualdad e IN. Reducen ligeramente la velocidad de las operaciones de inserción y actualización. Los índices utilizan memoria y ocupan más espacio en el archivo realm. Cada entrada de índice tiene un mínimo de 12 bytes. Se recomienda agregar índices solo cuando se optimiza el rendimiento de lectura en situaciones específicas.

Realm supports indexing for string, integer, boolean, Date, UUID, ObjectId, and AnyRealmValue properties.

class Book: Object {
    @Persisted var priceCents = 0
    @Persisted(indexed: true) var title = ""
}

@interface Book : RLMObject
@property int priceCents;
@property NSString *title;
@end
@implementation Book
// Return a list of indexed property names
+ (NSArray *)indexedProperties {
    return @[@"title"];
}
@end

class Book: Object {
    @objc dynamic var priceCents = 0
    @objc dynamic var title = ""
    // Return a list of indexed property names
    override static func indexedProperties() -> [String] {
        return ["title"]
    }
}

Ignorar una propiedad

Las propiedades ignoradas se comportan igual que las propiedades normales. No se pueden usar en consultas ni activan notificaciones de Realm. Aun así, puedes observarlas usando KVO.

class Person: Object {
    // If some properties are marked as @Persisted,
    // any properties that do not have the @Persisted
    // annotation are automatically ignored.
    var tmpId = 0
    // The @Persisted properties are managed
    @Persisted var firstName = ""
    @Persisted var lastName = ""
    // Read-only properties are automatically ignored
    var name: String {
        return "\(firstName) \(lastName)"
    }
    // If you mix the pre-10.10 property declaration
    // syntax `@objc dynamic` with the 10.10+ @Persisted
    // annotation within a class, `@objc dynamic`
    // properties are ignored.
    @objc dynamic var email = ""
}

@interface Person : RLMObject
@property NSInteger tmpId;
@property (readonly) NSString *name; // read-only properties are automatically ignored
@property NSString *firstName;
@property NSString *lastName;
@end
@implementation Person
+ (NSArray *)ignoredProperties {
    return @[@"tmpId"];
}
- (NSString *)name {
    return [NSString stringWithFormat:@"%@ %@", self.firstName, self.lastName];
}
@end

class Person: Object {
    @objc dynamic var tmpId = 0
    @objc dynamic var firstName = ""
    @objc dynamic var lastName = ""
    // Read-only properties are automatically ignored
    var name: String {
        return "\(firstName) \(lastName)"
    }
    // Return a list of ignored property names
    override static func ignoredProperties() -> [String] {
        return ["tmpId"]
    }
}

Declarar propiedades Enum

// Define the enum
enum TaskStatusEnum: String, PersistableEnum {
    case notStarted
    case inProgress
    case complete
}
// To use the enum:
class Task: Object {
    @Persisted var name: String = ""
    @Persisted var owner: String?
    // Required enum property
    @Persisted var status = TaskStatusEnum.notStarted 
    // Optional enum property
    @Persisted var optionalTaskStatusEnumProperty: TaskStatusEnum? 
}

// Define the enum
@objc enum TaskStatusEnum: Int, RealmEnum {
    case notStarted = 1
    case inProgress = 2
    case complete = 3
}
// To use the enum:
class Task: Object {
    @objc dynamic var name: String = ""
    @objc dynamic var owner: String?
    // Required enum property
    @objc dynamic var status = TaskStatusEnum.notStarted 
    // Optional enum property
    let optionalTaskStatusEnumProperty = RealmProperty<TaskStatusEnum?>() 
}

Remap a Property Name

You can map the public name of a property in your object model to a different private name to store in the realm. You might want to do this if your Device Sync schema property names use snake case, for example, while your project uses Swift-idiomatic camel case.

Declare el nombre que desea usar en su proyecto como la propiedad @Persisted en el modelo de objetos. Luego, pase un diccionario con los valores públicos y privados de los nombres de las propiedades mediante la función propertiesMapping().

In this example, firstName is the public property name we use in the code throughout the project to perform CRUD operations. Using the propertiesMapping() function, we map that to store values using the private property name first_name in the realm. If we write to a synced realm, the Sync schema sees the values stored using the private property name first_name.

class Person: Object {
    @Persisted var firstName = ""
    @Persisted var lastName = ""
    
    override class public func propertiesMapping() -> [String: String] {
        ["firstName": "first_name",
         "lastName": "last_name"]
    }
}

Acerca de estos ejemplos

The examples in this section use a simple data set. The two Realm object types are Person and an embedded object Address. A Person has a first and last name, an optional Address, and a list of friends consisting of other Person objects. An Address has a city and country.

See the schema for these two classes, Person and Address, below:

class Person: Object {
    @Persisted var firstName = ""
    @Persisted var lastName = ""
    @Persisted var address: Address?
    @Persisted var friends = List<Person>()
}
class Address: EmbeddedObject {
    @Persisted var city: String = ""
    @Persisted var country = ""
}

Cómo definir una proyección de clase

Define a class projection by creating a class of type Projection. Specify the Object or EmbeddedObject base whose properties you want to use in the class projection. Use the @Projected property wrapper to declare a property that you want to project from a @Persisted property on the base object.

class PersonProjection: Projection<Person> {
    @Projected(\Person.firstName) var firstName // Passthrough from original object
    @Projected(\Person.address?.city) var homeCity // Rename and access embedded object property through keypath
    @Projected(\Person.friends.projectTo.firstName) var firstFriendsName: ProjectedCollection<String> // Collection mapping
}

When you define a class projection, you can transform the original @Persisted property in several ways:

• Passthrough: la propiedad tiene el mismo nombre y tipo que el objeto original

• Rename: the property has the same type as the original object, but a different name

• Resolución de ruta de clave: utilice la resolución de ruta de clave para acceder a las propiedades del objeto original, incluidas las propiedades del objeto incrustado

• Mapeo de colección: el proyecto lista o conjuntos mutables de Object s o EmbeddedObject s como una colección de valores primitivos

• Exclusión: cuando se utiliza una proyección de clase, se excluyen las propiedades del objeto subyacente que no se proyectan a @Projected través de la proyección de clase. Esto permite observar cambios en una proyección de clase y no ver cambios en propiedades que no formen parte de la proyección de clase.