Menu Docs
Página inicial do Docs
/
MongoDB Atlas
/
Serviços Atlas App
/
Definir um Modelo de Dados

Relacionamentos

Nesta página

  • Visão geral
  • Cardinalidade
  • Para-um
  • Para muitos
  • Relacionamentos de objetos incorporados
  • Objeto incorporado a outra coleção
  • Objeto incorporado em uma lista
  • Definir uma relação
  • Definir esquemas
  • Crie um novo relacionamento
  • Configurar a relação
  • Implemente a relação

Visão geral

Um relacionamento é uma conexão entre dois documentos. Os relacionamentos permitem consultar e fazer query a documentos relacionados em operações de leitura e gravação, mesmo que os documentos estejam em bancos de dados ou collections separados.

Você define um relacionamento em uma coleção de origem do MongoDB e faz um link para documentos em uma coleção externa. O Atlas App Services resolve automaticamente os relacionamentos em modelos de dados do SDK sincronizados, substituindo os valores em um campo de origem pelos documentos estrangeiros aos quais eles fazem referência.

Os relacionamentos são unidirecionais e não impõem exclusividade ou outras restrições de chaves estrangeiras. Se você referenciar um valor estrangeiro inexistente em um campo de origem, o App Services omite automaticamente a referência de relacionamentos resolvidos.

Exemplo

Considere um aplicativo com duas collections:

  • A coleção accounts contém documentos que descrevem uma conta de cliente.

    Esquema de Coleta de Conta
    {
      "title": "Account",
      "properties": {
        "_id": { "bsonType": "objectId" },
        "account_id": { "bsonType": "string" },
        "products": {
          "bsonType": "array",
          "items": { "bsonType": "string" }
        },
        ...
      }
    }

  • A collection customers contém documentos que descrevem um único cliente que pode ter uma ou mais contas. Cada documento na collection customers tem um campo accounts que contém uma array de cada valor account_id da collection accounts que se aplica ao cliente.

    Esquema de collection do cliente
    {
      "title": "Customer",
      "properties": {
        "username": { "bsonType": "string" },
        "accounts": {
          "bsonType": "array",
          "items": { "bsonType": "string" }
        },
        ...
      }
    }

O aplicativo define este relacionamento na coleção customers. Ele aponta da array de valores de id da conta armazenados no campo accounts para o campo account_id de cada documento na coleção accounts.

{
  "accounts": {
    "ref": "#/relationship/mongodb-atlas/sample_analytics/accounts",
    "foreign_key": "account_id",
    "is_list": true
  }
}

Com esse relacionamento definido, o App Services pode retornar um cliente e todas as suas contas em queries de cliente . Sem um relacionamento, as queries retornariam uma lista de apenas account_id valores em vez dos Account objetos completos.

Cardinalidade

A cardinalidade de uma relação determina o número de documentos estrangeiros que ela pode referenciar. O App Services oferece suporte a duas cardinalidades de relacionamento: "para-um" e "para-muitos".

Para-um

Um relacionamento entre si vincula cada documento de origem a um único documento ou a uma array de documentos da coleção estrangeira.

Para indicar que um relacionamento tem cardinalidade "para-um", defina is_list como false:

data_sources/mongodb-atlas/example/pets/relationships.json
{
  "owner": {
    "ref": "#/relationship/mongodb-atlas/example/people",
    "foreign_key": "_id",
    "is_list": false
  }
}

O App Services substitui automaticamente os valores de origem pelos objetos referenciados ou por um valor nulo nos modelos do SDK:

{
  "name": "Pet",
  "properties": {
    "name": "string",
    "owner": "Person"
  }
}
{
  "name": "Person",
  "properties": {
    "name": "string"
  }
}

Para muitos

Um relacionamento entre muitos vincula cada documento de origem a uma lista de documentos da coleção estrangeira.

Para indicar que um relacionamento tem cardinalidade "para-muitos", defina is_list como true:

data_sources/mongodb-atlas/example/people/relationships.json
{
  "pets": {
    "ref": "#/relationship/mongodb-atlas/example/pets",
    "foreign_key": "_id",
    "is_list": true
  }
}

O App Services substitui automaticamente os valores de origem pelos objetos referenciados ou por um valor nulo nos modelos do SDK:

{
  "name": "Pet",
  "properties": {
    "name": "string"
  }
}
{
  "name": "Person",
  "properties": {
    "name": "string",
    "pets": "Pet[]"
  }
}

Relacionamentos de objetos incorporados

Objetos incorporados podem ter relacionamentos com coleções estrangeiras. Use a notação de pontos para acessar propriedades em objetos incorporados.

Objeto incorporado a outra coleção

Um objeto incorporado pode ter um relacionamento com um objeto em uma collection externa.

{
  "title": "Person",
  "properties": {
    "_id": { "bsonType": "objectId" },
    "pet": {
      "bsonType":"object",
      "properties": {
        "favoriteToyBrand": { "bsonType": "objectId" }
      }
    }
    // ...additional model properties
  }
}

Use a notação de ponto para especificar a propriedade do objeto incorporado que tem um relacionamento com a collection externa. Em seguida, especifique os detalhes da collection externa e o campo de chave externa.

{ "pet.favoriteToyBrand":
   {
      "ref": "#/relationship/mongodb-atlas/example/ToyBrand",
      "foreign_key": "_id",
      "is_list": false }
}

Objeto incorporado em uma lista

Um objeto incorporado dentro de uma propriedade de lista pode ter um relacionamento com uma collection externa.

{
  "title": "Person",
  "properties": {
    "_id": { "bsonType": "objectId" },
    "pets": {
      "bsonType":"array",
      "items": {
        "bsonType": "object",
        "properties": {
          "favoriteToyBrand": { "bsonType": "objectId" }
        }
      }
    }
   // ...additional model properties
  }
}

Para acessar uma propriedade de objeto incorporado em uma lista, use field1.[].field2 (por exemplo, pets.[].favoriteToyBrand). Em seguida, especifique os detalhes da collection externa e o campo de chave externa.

Dica

Use a mesma sintaxe com dicionários e conjuntos

Você pode usar esta mesma sintaxe do field1.[].field2 ao criar relacionamentos dentro de dicionários e conjuntos.

{
  "pets.[].favoriteToyBrand": {
    "ref": "#/relationship/mongodb-atlas/example/ToyBrand",
    "foreign_key": "_id",
    "is_list": false
  }
}

Observação

Primitivos versus listas, dicionários e conjuntos em relacionamentos

No exemplo acima, is_list está definido como falso. O campo no final da string de relacionamento é uma primitiva, não uma lista. O objeto incorporado está contido em uma lista, mas a propriedade favoriteToyBrand em si não é um dicionário, conjunto ou lista.

Definir uma relação

Ao definir um relacionamento, lembre-se das seguintes limitações:

  • O campo de referência (source) não pode ser _id.

  • O campo de referência (fonte) não pode ser um campo required .

  • Se você estiver usando o Device Sync, a chave externa deve ser o campo _id da collection externa.

1

Definir esquemas

Para definir um relacionamento, você deve ter um esquema definido tanto para a coleção de origem quanto para a coleta estrangeira. Para saber como definir esquemas, consulte Definir e aplicar um esquema.

2

Crie um novo relacionamento

Defina um relacionamento de collections em uma fonte de dados vinculada do MongoDB junto com o esquema.

Para criar um novo relacionamento:

  1. Clique em Schema no menu de navegação esquerdo.

  2. Na aba Collections , selecione a coleção de origem.

  3. Alterne View para Visualização JSON e clique em + Add Relationship.

Para criar um novo relacionamento , adicione um objeto de configuração de relacionamento ao arquivo relationships.json da collection de origem:

{
  "<source field>": {
    "ref": "#/relationship/<data source>/<db>/<collection>",
    "foreign_key": "<foreign field>",
    "is_list": <boolean>
  }
}
3

Configurar a relação

Uma definição de relacionamento mapeia de um campo de referência no esquema da collection de origem para um campo externo do mesmo tipo no esquema da collection externa.

Para configurar o relacionamento:

  1. Especifique o campo na coleção de origem a partir da qual o relacionamento mapeia. Isso é chamado de pai na interface do usuário.

  2. Especifique o banco de dados externo, a collection e o campo na collection externa para mapear para o campo de origem. Eles são chamados de vinculados na interface do usuário. Se você estiver usando o Device Sync, o campo vinculado deverá ser _id.

  3. Clique em Add.

Para configurar o relacionamento, especifique o nome do campo de origem como um campo de nível raiz no relationships.json e, em seguida, adicione as seguintes opções de configuração no valor do campo:

  • Especifique a collection externa no campo ref usando o seguinte formato:

    #/relationship/<data source>/<db>/<collection>

  • Especifique o campo a ser correspondido no campo foreign_key . Se você estiver usando o Device Sync, deve ser _id.

  • Se o campo de origem contiver uma array, defina is_list como true, caso contrário, defina-o como false.

4

Implemente a relação

Clique em Save e distribua seu aplicativo atualizado.

Salve o arquivo de configuração de relacionamento e envie suas alterações para implementá-las:

appservices push

Voltar

Tipos de dados de esquema

Próximo

Values & Secrets