Relacionamentos de modelo - Swift SDK

Nesta página

Declarar propriedades de relacionamento

Definir uma propriedade de relacionamento um-para-um
Definir uma propriedade de relacionamento um-para-muitos
Definir uma propriedade de relacionamento inversa
Definir uma propriedade de objeto embarcado

Os Atlas Device SDKs estão obsoletos. Consulte apágina de descontinuação do para detalhes.

Declarar propriedades de relacionamento

Dica

Veja também:

Como alternativa, você pode definir seus relacionamentos no App Services App.

Definir uma propriedade de relacionamento um-para-um

Um relacionamento para um mapeia uma propriedade para uma instância única de outro tipo de objeto. Por exemplo, você pode modelar uma pessoa que tenha, no máximo, um cão de companhia como um relacionamento para um.

Definir um campo de relacionamento como nulo remove a conexão entre objetos. No entanto, o Realm não exclui o objeto referenciado, a menos que seja um objeto incorporado.

Importante

Relacionamentos um-para-um devem ser opcionais

Quando você declara um relacionamento um-para-um no modelo de objeto, ele deve ser uma propriedade opcional. Se você tentar tornar um relacionamento um-para-um obrigatório, o Realm lançará uma exceção em tempo de execução.

// Dog.h
@interface Dog : RLMObject
@property NSString *name;
// No backlink to person -- one-directional relationship
@end
// Define an RLMArray<Dog> type
RLM_COLLECTION_TYPE(Dog)
// Person.h
@interface Person : RLMObject
@property NSString *name;
// A person can have one dog
@property Dog *dog;
@end
// Dog.m
@implementation Dog
@end
// Person.m
@implementation Person
@end

class Person: Object {
    @Persisted var name: String = ""
    @Persisted var birthdate: Date = Date(timeIntervalSince1970: 1)
    // A person can have one dog
    @Persisted var dog: Dog?
}
class Dog: Object {
    @Persisted var name: String = ""
    @Persisted var age: Int = 0
    @Persisted var breed: String?
    // No backlink to person -- one-directional relationship
}

Dica

Veja também:

Para obter mais informações sobre relacionamentos um-para-um, consulte: Relacionamento um-para-um.

Se seu aplicativo usa o Device Sync, consulte a página Dados do modelo com sincronia de dispositivo para obter informações sobre como o relacionamento para um e outro em modelos de objetos Swift se traduz em documentos Atlas.

Definir uma propriedade de relacionamento um-para-muitos

Uma relação para muitos mapeia uma propriedade para zero ou mais instâncias de outro tipo de objeto. Por exemplo, você pode modelar uma pessoa com qualquer número de cães de companhia como um relacionamento para muitos.

Use RLMArray marcado com seu tipo de destino para definir sua propriedade de relacionamento para muitos.

Dica

Lembre-se de usar a macro RLM_COLLECTION_TYPE() com seu tipo para declarar o protocolo RLMArray para seu tipo.

// Dog.h
@interface Dog : RLMObject
@property NSString *name;
// No backlink to person -- one-directional relationship
@end
// Define an RLMArray<Dog> type
RLM_COLLECTION_TYPE(Dog)
// Person.h
@interface Person : RLMObject
@property NSString *name;
// A person can have many dogs
@property RLMArray<Dog *><Dog> *dogs;
@end
// Dog.m
@implementation Dog
@end
// Person.m
@implementation Person
@end

Use Lista marcada com seu tipo de destino para definir sua propriedade de relacionamento para muitos.

class Person: Object {
    @Persisted var name: String = ""
    @Persisted var birthdate: Date = Date(timeIntervalSince1970: 1)
    // A person can have many dogs
    @Persisted var dogs: List<Dog>
}
class Dog: Object {
    @Persisted var name: String = ""
    @Persisted var age: Int = 0
    @Persisted var breed: String?
    // No backlink to person -- one-directional relationship
}

Dica

Veja também:

Para obter mais informações sobre relacionamentos um-para-muitos, consulte: Relacionamento um-para-muitos.

Se seu aplicativo usa a sincronização de dispositivos, consulte a página Dados do modelo com sincronização de dispositivos para obter informações sobre como a relação para muitos nos modelos de objetos Swift se traduz em documentos Atlas.

Definir uma propriedade de relacionamento inversa

Uma propriedade de relacionamento inverso é uma relação automática de backlink. O Realm atualiza automaticamente as relações implícitas sempre que um objeto é adicionado ou removido em uma lista de muitos ou em uma propriedade de relação de um para um correspondente. Você não pode definir manualmente o valor de uma propriedade de relacionamento inversa.

Para definir uma relacionamento inversa, use LinkingObjects em seu modelo de objetos. A definição LinkingObjects especifica o tipo de objeto e o nome da propriedade do relacionamento que inverte.

class User: Object {
    @Persisted(primaryKey: true) var _id: ObjectId
    @Persisted var _partition: String = ""
    @Persisted var name: String = ""
    // A user can have many tasks.
    @Persisted var tasks: List<Task>
}
class Task: Object {
    @Persisted(primaryKey: true) var _id: ObjectId
    @Persisted var _partition: String = ""
    @Persisted var text: String = ""
    // Backlink to the user. This is automatically updated whenever
    // this task is added to or removed from a user's task list.
    @Persisted(originProperty: "tasks") var assignee: LinkingObjects<User>
}

Para definir um relacionamento inverso, use RLMLinkingObjects em seu modelo de objetos. Substitua o método +[RLMObject linkingObjectProperties] em sua classe para especificar o tipo de objeto e o nome da propriedade do relacionamento que ele inverte.

// Task.h
@interface Task : RLMObject
@property NSString *description;
@property (readonly) RLMLinkingObjects *assignees;
@end
// Define an RLMArray<Task> type
RLM_COLLECTION_TYPE(Task)
// User.h
@interface User : RLMObject
@property NSString *name;
@property RLMArray<Task *><Task> *tasks;
@end
// Task.m
@implementation Task
+ (NSDictionary *)linkingObjectsProperties {
    return @{
        @"assignees": [RLMPropertyDescriptor descriptorWithClass:User.class propertyName:@"tasks"],
    };
}
@end
// User.m
@implementation User
@end

Para definir uma relacionamento inversa, use LinkingObjects em seu modelo de objetos. A definição LinkingObjects especifica o tipo de objeto e o nome da propriedade do relacionamento que inverte.

class User: Object {
    @objc dynamic var _id: ObjectId = ObjectId.generate()
    @objc dynamic var _partition: String = ""
    @objc dynamic var name: String = ""
    // A user can have many tasks.
    let tasks = List<Task>()
    override static func primaryKey() -> String? {
        return "_id"
    }
}
class Task: Object {
    @objc dynamic var _id: ObjectId = ObjectId.generate()
    @objc dynamic var _partition: String = ""
    @objc dynamic var text: String = ""
    // Backlink to the user. This is automatically updated whenever
    // this task is added to or removed from a user's task list.
    let assignee = LinkingObjects(fromType: User.self, property: "tasks")
    override static func primaryKey() -> String? {
        return "_id"
    }
}

Dica

Veja também:

Para obter mais informações sobre relacionamentos inversos, consulte: Relacionamento inverso.

Se o seu aplicativo usa o Device Sync, consulte a página Modelar dados com o Device Sync para obter informações sobre como a relação inversa nos modelos de objetos Swift se traduz em documentos Atlas.

Definir uma propriedade de objeto embarcado

Existe um objeto incorporado como dados aninhados dentro de um único objeto pai específico. Ele herda o ciclo de vida de seu objeto pai e não pode existir como um objeto Realm independente. O Realm exclui automaticamente os objetos incorporados se o objeto pai for excluído ou quando for substituído por uma nova instância de objeto incorporado.

Observação

O Realm usa exclusões em cascata para objetos embarcados

Ao excluir um Objeto de Realm, todos os objetos embarcados referenciados por esse objeto são excluídos com ele. Se você deseja que os objetos referenciados persistam após a exclusão do objeto principal , o tipo não pode ser objeto incorporado . Em vez disso, use um Objeto de Realm comum com um relacionamento de um para um.

Você pode definir um objeto incorporado derivando da classe RLMEmbeddedObject . Você pode usar seu objeto incorporado em outro modelo como faria com qualquer outro tipo.

// Define an embedded object
@interface Address : RLMEmbeddedObject
@property NSString *street;
@property NSString *city;
@property NSString *country;
@property NSString *postalCode;
@end
// Enable Address for use in RLMArray
RLM_COLLECTION_TYPE(Address)
@implementation Address
@end
// Define an object with one embedded object
@interface Contact : RLMObject
@property NSString *name;
// Embed a single object.
@property Address *address;
@end
@implementation Contact
@end
// Define an object with an array of embedded objects
@interface Business : RLMObject
@property NSString *name;
// Embed an array of objects
@property RLMArray<Address *><Address> *addresses;
@end

Você pode definir um objeto incorporado derivando da classe EmbeddedObject. Você pode usar seu objeto incorporado em outro modelo como faria com qualquer outro tipo.

class Person: Object {
    @Persisted(primaryKey: true) var id = 0
    @Persisted var name = ""
    // To-many relationship - a person can have many dogs
    @Persisted var dogs: List<Dog>
    // Inverse relationship - a person can be a member of many clubs
    @Persisted(originProperty: "members") var clubs: LinkingObjects<DogClub>
    // Embed a single object.
    // Embedded object properties must be marked optional.
    @Persisted var address: Address?
    convenience init(name: String, address: Address) {
        self.init()
        self.name = name
        self.address = address
    }
}
class DogClub: Object {
    @Persisted var name = ""
    @Persisted var members: List<Person>
    // DogClub has an array of regional office addresses.
    // These are embedded objects.
    @Persisted var regionalOfficeAddresses: List<Address>
    convenience init(name: String, addresses: [Address]) {
        self.init()
        self.name = name
        self.regionalOfficeAddresses.append(objectsIn: addresses)
    }
}
class Address: EmbeddedObject {
    @Persisted var street: String?
    @Persisted var city: String?
    @Persisted var country: String?
    @Persisted var postalCode: String?
}

Dica

Veja também:

Se o seu aplicativo utilizar Device Sync, consulte a página Modelar Dados com Sincronização de Dispositivo para informações sobre como objetos incorporados em modelos de objeto Swift se traduzem em documentos Atlas.

Voltar

Definir um modelo de objeto

Tipos suportados