Menu Docs

Página inicial do Docs → Desenvolver aplicações → Atlas Device SDKs

Modelar dados com sincronização de dispositivo - SDK rápido

Nesta página

  • Realm Object Models
  • Esquema JSON
  • Realm relacionamento
  • Relacionamento para um
  • Relacionamento com muitos
  • Relacionamento inverso
  • Modelos de objetos incorporados
  • Criar modelo de objetos e esquemas de objeto

Realm Object Models

Para definir um objeto de Realm, derive uma classe de Object. Os modelos que você define cada mapa para sua própria coleção no MongoDB Atlas. Neste exemplo, Dog e Person mapeariam para separar collections no MongoDB Atlas.

class Dog: Object {
   @Persisted(primaryKey: true) var _id = ObjectId()
   @Persisted var name = ""
   @Persisted var age = 0
}
class Person: Object {
   @Persisted(primaryKey: true) var _id = ObjectId()
   @Persisted var name = ""
}

Esquema JSON

Quando você tem um esquema correspondente no Atlas App Services, o Realm Mobile Sync converte automaticamente os tipos de dados do Realm Swift em BSON à medida que é sincronizado com o Atlas. Quando o dispositivo cliente sincroniza os dados do App Services por meio do Realm Mobile Sync, o SDK converte os BSON de volta para objeto Swift. Se você query esses objeto acessando os dados do MongoDB Atlas diretamente, em vez de usar o Realm Mobile Sync para sincronizar os dados, obterá os tipos de dados BSON. O MongoDB Data Access não é mapeado automaticamente para os equivalentes do objeto Swift.

Esquema de cães no App Services
{
  "title": "Dog",
  "bsonType": "object",
  "required": [
    "_id"
  ],
  "properties": {
    "_id": {
      "bsonType": "objectId"
    },
    "name": {
      "bsonType": "string"
    },
    "age": {
      "bsonType": "long"
    }
  }
}
Esquema de pessoa no App Services
{
  "title": "Person",
  "bsonType": "object",
  "required": [
    "_id"
  ],
  "properties": {
    "_id": {
      "bsonType": "objectId"
    },
    "name": {
      "bsonType": "string"
    }
  }
}

Realm relacionamento

Relacionamento para um

Usando os objetos no exemplo acima, considere um caso em que um Person pode ter um Dog. Podemos adicionar uma propriedade dog ao nosso modelo Person que é um link opcional para um objeto Dog . Relacionamento um-para-um devem ser opcionais.

class Dog: Object {
   @Persisted(primaryKey: true) var _id = ObjectId()
   @Persisted var name = ""
   @Persisted var age = 0
}
class Person: Object {
   @Persisted(primaryKey: true) var _id = ObjectId()
   @Persisted var name = ""
   // To-one relationship
   @Persisted var dog: Dog?
}

Esquema JSON

No esquema do App Services, vemos a nova propriedade ser convertida em um campo dog. O campo não está na array required porque é uma propriedade opcional. Seu tipo é um objectId vinculado a um objeto Dog específico na collection Dog separada. O ObjectId é a chave primária do modelo Dog, portanto, é o campo que vincula os dois objeto.

Pessoa com relacionamento um-para-um com o cão
{
  "title": "Person",
  "bsonType": "object",
  "required": [
    "_id"
  ],
  "properties": {
    "_id": {
      "bsonType": "objectId"
    },
    "dog": {
      "bsonType": "objectId"
    },
    "name": {
      "bsonType": "string"
    }
  }
}

O esquema Dog não muda. Como este é um relacionamento para um, é um relacionamento unidirecional; o Dog não tem relacionamento com Person.

Dica

Veja também:

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

Relacionamento com muitos

Utilizando os objetos no exemplo acima, considere um caso em que um Person pode ter muitos cães. Podemos adicionar uma propriedade dogs ao nosso modelo Person que é uma lista de objetos Dog . Se a pessoa não tiver cachorros, esta é uma lista vazia. À medida que a pessoa vai pegando cachorros, podemos criar novos objetos cachorro e anexá-los à lista dogs da pessoa.

class Dog: Object {
   @Persisted(primaryKey: true) var _id = ObjectId()
   @Persisted var name = ""
   @Persisted var age = 0
}
class Person: Object {
   @Persisted(primaryKey: true) var _id = ObjectId()
   @Persisted var name = ""
   // To-many relationship - a person can have many dogs
   @Persisted var dogs: List<Dog>
}

Esquema JSON

No esquema do App Services, vemos a nova propriedade ser convertida em um campo dogs. O tipo deste campo é uma matriz, os itens na matriz são do tipo objectId. Isso ocorre porque definimos a chave primária em nosso modelo Dog como objectId. Este campo é uma array das chaves primárias de todos os objetos Dog relacionados ao objeto Person .

Pessoa com relacionamento para muitos com cão
{
  "title": "Person",
  "bsonType": "object",
  "required": [
    "_id"
  ],
  "properties": {
    "_id": {
      "bsonType": "objectId"
    },
    "name": {
      "bsonType": "string"
    },
    "dogs": {
      "bsonType": "array",
      "items": {
        "bsonType": "objectId"
      }
    }
  }
}

Dica

Veja também:

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

Relacionamento inverso

Utilizando os objeto no exemplo acima, considere um caso em que o objeto Dog tem um relacionamento inversa ao objeto Person .

class Dog: Object {
   @Persisted(primaryKey: true) var _id = ObjectId()
   @Persisted var name = ""
   @Persisted var age = 0
   // The backlink to the `Person` who has this `Dog`.
   @Persisted(originProperty: "dogs") var person: LinkingObjects<Person>
}
class Person: Object {
   @Persisted(primaryKey: true) var _id = ObjectId()
   @Persisted var name = ""
   // To-many relationship - a person can have many dogs
   @Persisted var dogs: List<Dog>
}

Esquema JSON

No esquema do App Services, vemos que a propriedade person que representa o relacionamento inverso para um Person do nosso modelo Dog não está presente. Não é possível definir diretamente o valor de um relacionamento inverso, e esse relacionamento não existe no Atlas. No entanto, o Realm deriva e atualiza esses relacionamentos para você no aplicativo cliente com base em seu modelo de objeto do Realm.

Cão com relacionamento inverso à pessoa
{
  "title": "Dog",
  "bsonType": "object",
  "required": [
    "_id"
  ],
  "properties": {
    "_id": {
      "bsonType": "objectId"
    },
    "name": {
      "bsonType": "string"
    },
    "age": {
      "bsonType": "long"
    }
  }
}

Dica

Veja também:

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

Modelos de objetos incorporados

Ao definir um objeto embarcado com o Realm Swift SDK, você deriva uma classe de EmbeddedObject. Você pode referenciar um tipo de objeto incorporado a partir dos tipos de objetos principais da mesma forma que definiria um relacionamento:

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

Esquema JSON

Objetos incorporados são mapeados para documentos incorporados no esquema do tipo principal. Este comportamento difere dos objetos regulares do Realm, que mapeiam para sua própria coleção MongoDB.

{
  "title": "Person",
  "bsonType": "object",
  "required": ["id"],
  "properties": {
    "id": { "bsonType": "int" },
    "name": { "bsonType": "string" },
    "dogs": {
      "bsonType": "array",
      "items": {
        "bsonType": "objectId"
      }
    },
    "address": {
      "title": "Address",
      "bsonType": "object",
      "properties": {
        "street": { "bsonType": "string" },
        "city": { "bsonType": "string" },
        "country": { "bsonType": "string" },
        "postalCode": { "bsonType": "string" }
      }
    }
  }
}
{
  "title": "DogClub",
  "bsonType": "object",
  "required": ["_id", "name", "addresses"],
  "properties": {
    "_id": "objectId",
    "name": { "bsonType": "string" },
    "members": {
      "bsonType": "array",
      "items": {
        "bsonType": "objectId"
      }
    },
    "addresses": {
      "bsonType": "array",
      "items": {
        "title": "Address",
        "bsonType": "object",
        "properties": {
          "street": { "bsonType": "string" },
          "city": { "bsonType": "string" },
          "country": { "bsonType": "string" },
          "postalCode": { "bsonType": "string" }
        }
      }
    }
  }
}

Criar modelo de objetos e esquemas de objeto

Para mapear entre modelos de objeto SDK e dados BSON no Atlas, você deve ter um esquema no App Services que corresponda ao seu modelo de objeto SDK. Há algumas maneiras de gerar modelos de esquema e objeto correspondentes:

  • Crie modelos de objetos no aplicativo cliente e gere esquemas do App Services a partir deles.

  • Crie esquemas no App Services e gere modelos de objetos do Realm a partir deles.

Se você estiver desenvolvendo um novo aplicativo cliente, provavelmente desejará iterar no modelo de dados no aplicativo cliente. Ative o Modo de desenvolvimento no App Services para que o backend infira e atualize o esquema com base nos seus modelos de objeto do cliente. O modo de desenvolvimento não funciona com alterações significativas de esquema, portanto, você deve remover o esquema existente do servidor ao fazer alterações significativas no modelo de dados do SDK.

Se você estiver desenvolvendo um aplicativo cliente que funcione com dados que já existem no Atlas, poderá gerar um esquema a partir desses dados. Em seguida, você pode gerar modelos de objeto SDK a partir do esquema do lado do servidor.

← Alterar um modelo de objeto - Swift SDK
CRUD - SDK rápido →

Nesta página