Definir um Realm Object Model - Swift SDK

Atributos de propriedade persistentes

Declare as propriedades do modelo que você deseja armazenar no banco de dados como @Persisted. Isso permite que elas acessem os dados do banco de dados subjacente.

Quando você declara quaisquer propriedades como @Persisted dentro de uma classe, as outras propriedades dentro desta classe são automaticamente ignoradas.

Se você misturar as declarações de propriedade @Persisted e @objc dynamic dentro de uma definição de classe, todos os atributos de propriedade marcados como @objc dynamic serão ignorados.

Atributos de propriedade dinâmica do Objective-C

Declare as propriedades do modelo dinâmico do Realm no tempo de execução do Objective-C. Isso permite que elas acessem os dados do banco de dados subjacente.

Você também pode:

• Use @objc dynamic var para declarar propriedades individuais

• Use @objcMembers para declarar uma classe. Em seguida, declare propriedades individuais com dynamic var.

Utilize let para declarar LinkingObjects, List, RealmOptional e RealmProperty. O tempo de execução do Objective-C não pode representar estas propriedades 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 uma propriedade opcional/obrigatória

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 uma chave primária

Você pode designar uma propriedade como chave primária da sua classe.

As chaves primárias permitem que você localize, atualize e insira objetos de forma eficiente.

As chaves primárias estão sujeitas às seguintes limitações:

• Você pode definir apenas uma chave primária por modelo de objeto.

• Os valores de chave primária devem ser únicos em todas as instâncias de um objeto em um domínio. O Realm apresenta um erro se você tentar inserir um valor de chave primária duplicado.

• Os valores de chave primária são imutáveis. Para alterar o valor da chave primária de um objeto, você deve excluir o objeto original e inserir um novo objeto com um valor de chave primária diferente.

• Objetos embarcados não podem definir uma chave primária.

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"
    }
}

Indexe uma propriedade

Você pode criar um índice em uma determinada propriedade do seu modelo. Índices aceleram queries usando operadores de igualdade e IN. Eles tornam a velocidade da operação de inserção e atualização um pouco mais lenta. Os índices usam memória e ocupam mais espaço no arquivo de Realm. Toda entrada do índice tem um mínimo de 12 bytes. É melhor adicionar índices somente ao otimizar o desempenho de leitura para situações específicas.

O Realm permite a indexação para propriedades de string, inteiro, booleano, Date, UUID, ObjectId e 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 uma propriedade

Propriedades ignoradas se comportam exatamente como propriedades normais. Elas não podem ser usadas em queries e não acionarão as notificações do Realm . Você ainda pode observá-los 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 propriedades 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?>() 
}

Remapear um nome de propriedade

Você pode mapear o nome público de uma propriedade em seu modelo de objeto para um nome privado diferente a ser armazenado no Realm. Talvez você queira fazer isso se os nomes das propriedades do esquema do Device Sync usarem letras maiúsculas e minúsculas, por exemplo, enquanto o projeto usa letras maiúsculas e minúsculas do Swift.

Declare o nome que você deseja utilizar em seu projeto como propriedade @Persisted no modelo de objeto. Em seguida, passe um dicionário contendo os valores públicos e privados para os nomes das propriedades por meio da função propertiesMapping().

Neste exemplo, firstName é o nome de propriedade pública que usamos no código ao longo do projeto para executar operações CRUD. Usando a função propertiesMapping() , mapeamos isso para armazenar valores usando o nome da propriedade privada first_name no Realm. Se escrevermos em um realm sincronizado, o esquema Sync verá os valores armazenados usando o nome da propriedade 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"]
    }
}

Sobre esses exemplos

Os exemplos nesta seção usam um conjunto de dados simples. Os dois tipos de objeto de Realm são Person e um objeto embarcado Address. Um Person tem um nome e sobrenome, um Addressopcional e uma lista de amigos que consiste em outros objetos Person. Um Address tem uma cidade e um país.

Consulte o esquema para estas duas classes, Person e Address, abaixo:

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 = ""
}

Como definir uma projeção de classe

Defina uma projeção de classe criando uma classe do tipo Projeção. Especifique a base Objeto ou Objeto embarcado cujas propriedades você deseja utilizar na projeção de classe. Use o wrapper de propriedade @Projected para declarar uma propriedade que você deseja projetar a partir de uma propriedade @Persisted no 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
}

Ao definir uma projeção de classe, você pode transformar a propriedade original @Persisted de várias maneiras:

• Passagem: a propriedade tem o mesmo nome e tipo que o objeto original

• Renomear: a propriedade tem o mesmo tipo do objeto original, mas outro nome

• Resolução de keypath: use a resolução de keypath para acessar as propriedades do objeto original, incluindo propriedades do objeto embarcado

• Mapeamento de collections:Listas de projetos ou conjuntos mutáveis de Object s ou EmbeddedObject s como uma collection de valores primitivos

• Exclusão: quando você usa uma projeção de classe, as propriedades subjacentes do objeto de Realm que não são @Projected por meio da projeção de classe são excluídas. Isso permite que você observe alterações em uma projeção de classe e não veja alterações em propriedades que não fazem parte da projeção de classe.