Definir un modelo de objeto de reino - Swift SDK

Atributos de propiedad persistentes

Declare las propiedades del modelo que desea almacenar en la base de datos como @Persisted. Esto les permite acceder a los datos subyacentes de la base de datos.

Cuando se declara cualquier propiedad como @Persisted dentro de una clase, las demás propiedades dentro de esa clase se ignoran automáticamente.

Si mezcla declaraciones de propiedades @Persisted y @objc dynamic dentro de una definición de clase, se ignorarán todos los atributos de propiedad marcados como @objc dynamic.

Atributos de propiedades dinámicas de Objective-C

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

Puedes:

• Utiliza @objc dynamic var para declarar propiedades individuales

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

Utilice let para declarar LinkingObjects, List, RealmOptional y RealmProperty. El entorno de ejecución de Objective-C no puede representar estas propiedades genéricas.

// 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

Especificar una propiedad opcional/obligatoria

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?>()
}

Especificar una clave principal

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

Las claves principales le permiten buscar, actualizar e insertar objetos de manera eficiente.

Las claves primarias están sujetas a las siguientes limitaciones:

• Puede definir solo una clave principal por modelo de objeto.

• Los valores de clave principal deben ser únicos en todas las instancias de un objeto en un dominio. El dominio genera un error si se intenta insertar un valor de clave principal duplicado.

• 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 para situaciones específicas.

Realm admite la indexación de propiedades de cadena, entero, booleano, Date, UUID, ObjectId y AnyRealmValue.

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?>() 
}

Reasignar un nombre de propiedad

Puedes asignar el nombre público de una propiedad en tu modelo de objetos a un nombre privado diferente para almacenarlo en el dominio. Esto podría ser útil si los nombres de propiedad de tu esquema de Device Sync usan la escritura en mayúsculas y minúsculas, por ejemplo, mientras que tu proyecto usa la escritura en mayúsculas y minúsculas típica de Swift.

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().

En este ejemplo, firstName es el nombre de la propiedad pública que usamos en el código del proyecto para realizar operaciones CRUD. Con la función propertiesMapping(), la asignamos para almacenar valores que usan la propiedad privada first_name en el dominio. Si escribimos en un dominio sincronizado, el esquema de sincronización ve los valores almacenados con la propiedad privada 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

Los ejemplos de esta sección utilizan un conjunto de datos simple. Los dos tipos de objeto Realm son Person y un objeto incrustado Address. Un Person contiene nombre y apellido, un Address opcional y una lista de amigos compuesta por otros Person objetos. Un Address contiene una ciudad y un país.

Vea el esquema de estas dos clases, Person y Address, a continuación:

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 una proyección de clase creando una clase de tipo Proyección.Especifica el objeto o el objeto incrustado base cuyas propiedades quieres usar en la proyección de clase. Usa el @Projected contenedor de propiedades para declarar una propiedad que quieras proyectar desde una @Persisted propiedad en el objeto base.

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
}

Cuando define una proyección de clase, puede transformar la propiedad original @Persisted de varias maneras:

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

• Cambiar nombre: la propiedad tiene el mismo tipo que el objeto original, pero un nombre diferente

• 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 colecciones:Proyecta listas 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.