Menu Docs

Página inicial do Docs → Serviços Atlas App

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
  • 1. Definir esquemas
  • 2. Crie um novo relacionamento
  • 3. Configurar a relação
  • 4. 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 para uma coleção "source" MongoDB e faz um link para documentos em uma coleção "foreign". 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 clientes. 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, p. ex., 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 não pode ser _id

  • O campo de referência não pode ser um campo required

  • A chave externa deve ser o campo _id da collection que o campo está usando como referência

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 Impor um esquema.

2. Crie um novo relacionamento

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

3. Configurar a relação

Uma definição de relacionamento mapeia a partir de um campo incluído no esquema da collection de origem e aponta para um campo do mesmo tipo no esquema da collection externa.

4. Implemente a relação

← Tipos de esquema
Valores & segredos →

Nesta página