Para agentes de IA: um índice de documentação está disponível em https://www.mongodb.com/pt-br/docs/llms.txt — as versões de markdown de todas as páginas estão disponíveis anexando .md a qualquer caminho de URL.
Make the MongoDB docs better! We value your opinion. Share your feedback for a chance to win $100.
MongoDB Branding Shape
Click here >
Menu Docs
Página inicial do Docs
/ /
Operadores e coletores
Página inicial do Docs
/ /
Referência de query
/
Operadores e coletores
Página inicial do Docs
/
Desenvolvimento
/
Pesquisa
/
Queries e índices
/
Referência de query
/
Operadores e coletores

embeddedDocument Operador

Definição

embeddedDocument

O operador embeddedDocument é semelhante ao operador $elemMatch. Ele restringe vários predicados da query a serem satisfeitos a partir de um único elemento de um array de documentos incorporados. embeddedDocument pode ser utilizado somente para query em campos do tipo embeddedDocuments.

Sintaxe

embeddedDocument tem a seguinte sintaxe:

{
  "embeddedDocument": {
    "path": "<path-to-field>",
    "operator": { <operator-specification> },
    "score": { <score-options> }
  }
}

Opções

embeddedDocument usa as seguintes opções para construir uma query:

Campo
Tipo
Descrição
necessidade

operator

objeto

Operador a utilizar para fazer a query de cada documento no array de documentos que você especifica no path. O operador moreLikeThis não é aceito.

Obrigatório

path

string

Campo de tipo embeddedDocuments indexado para pesquisa. O campo especificado deve ser pai de todos os operadores e campos especificados utilizando a opção operator.

Obrigatório

score

objeto

Pontuação a ser atribuída aos resultados correspondentes do Atlas Search . Você pode utilizar a opção de pontuação embedded para configurar as opções de pontuação. Para saber mais, consulte Comportamento de pontuação.

Opcional

embeddedDocument Limitações do operador

Você não pode usar o realce em queries dentro do operador embeddedDocument.

Observação

O MongoDB Search para de replicar alterações para índices maiores que 2,100,000,000 objetos de índice por partição, em um conjunto de réplicas ou shard único, onde cada documento pai incorporado indexado conta como um único objeto. Exceder este limite pode resultar em resultados de query obsoletos.

O uso do tipo de campo embeddedDocuments pode resultar na indexação de objetos acima desse limite de tamanho de índice, porque cada documento incorporado indexado é contado como um único objeto. Se você criar um índice de pesquisa do MongoDB que tenha ou em breve terá mais de 2.1 bilhões de objetos de índice, use a opção de índice numPartitions para particionar seu índice (compatível somente na implantação de nós de pesquisa) ou shard seu cluster.

Comportamento

Quando você faz uma query de documentos incorporados a arrays usando o operador embeddedDocument, o MongoDB Search avalia e pontua os predicados da query do operador em diferentes estágios de sua execução. Pesquisa do MongoDB :

  1. Avalia cada documento incorporado na array de forma independente.

  2. Combina as pontuações dos resultados correspondentes conforme configurado usando a opção embedded ou as pontuações somando as pontuações dos resultados correspondentes se você não especificar uma opção de pontuação embedded.

  3. Associa os resultados correspondentes ao documento-pai se outros predicados da query forem especificados pelo composto.

Comportamento de pontuação

Por padrão, o operador embeddedDocument usa a estratégia de agregação padrão, sum, para combinar pontuações de correspondências de documentos incorporados. A opção embeddedDocument do operador score permite que você substitua o padrão e configure a pontuação dos resultados correspondentes utilizando a opção embedded.

Dica

Classificar os documentos nos resultados

Comportamento de classificação

Para classificar os documentos-pai por um campo de documento incorporado, faça o seguinte:

  • Indexe os pais do campo filho do documento incorporado como o tipo de documento .

  • Indexe o campo secundário com valores de string dentro do documento incorporado como o tipo de token . Para campos secundários com valores numéricos e de data, habilite o mapeamento dinâmico para indexar esses campos automaticamente.

A Pesquisa do MongoDB classifica apenas em documentos principais. Não classifica os campos filhos em uma array de documentos. Para obter um exemplo, consulte Exemplo de classificação.

Realce

Você pode fazer realces em campos se os campos forem indexados em um campo principal do tipo de documento para predicados de consulta especificados dentro do operador embeddedDocument. Para ver um exemplo, consulte tutorial.

Para saber mais sobre as limitações do operador embeddedDocument, consulte Limitações do operadorembeddedDocument.

Exemplos

Os exemplos seguintes utilizam a coleção sample_supplies.sales no conjunto de dados de amostra.

Definição de Índice

Essas consultas de exemplo usam a seguinte definição de índice na coleção:

{
  "mappings": {
    "dynamic": true,
    "fields": {
      "items": [
        {
          "dynamic": true,
          "type": "embeddedDocuments"
        },
        {
          "dynamic": true,
          "fields": {
            "tags": {
              "type": "token"
            }
          },
          "type": "document"
        }
      ],
      "purchaseMethod": {
        "type": "token"
      }
    }
  }
}

Query básica

A query abaixo pesquisa a collection por itens marcados com school, com preferência para itens denominados backpack. O MongoDB Search pontua os resultados em ordem decrescente com base na pontuação média ( média aritmética ) de todos os documentos incorporados correspondentes. A query inclui um estágio de $limit para limitar o resultado a 5 documentos e um estágio de $project para:

  • Exclua todos os campos, exceto os campos items.name e items.tags

  • Adicione um campo chamado score

1db.sales.aggregate({
2  "$search": {
3    "embeddedDocument": {
4      "path": "items",
5      "operator": {
6        "compound": {
7          "must": [{
8            "text": {
9              "path": "items.tags",
10              "query": "school"
11            }
12          }],
13          "should": [{
14            "text": {
15              "path": "items.name",
16              "query": "backpack"
17            }
18          }]
19        }
20      },
21      "score": {
22        "embedded": {
23          "aggregate": "mean"
24        }
25      }
26    }
27  }
28},
29{
30  $limit: 5
31},
32{
33  $project: {
34    "_id": 0,
35    "items.name": 1,
36    "items.tags": 1,
37    "score": { $meta: "searchScore" }
38  }
39})
[
  {
    items: [ {
      name: 'backpack',
      tags: [ 'school', 'travel', 'kids' ]
    } ],
    score: 1.2907354831695557
  },
  {
    items: [ {
      name: 'envelopes',
      tags: [ 'stationary', 'office', 'general' ]
    },
    {
      name: 'printer paper',
      tags: [ 'office', 'stationary' ]
    },
    {
      name: 'backpack',
      tags: [ 'school', 'travel', 'kids' ]
    } ],
    score: 1.2907354831695557
  },
  {
    items: [ {
      name: 'backpack',
      tags: [ 'school', 'travel', 'kids' ]
    } ],
    score: 1.2907354831695557
  },
  {
    items: [ {
      name: 'backpack',
      tags: [ 'school', 'travel', 'kids' ]
    } ],
    score: 1.2907354831695557
  },
  {
    items: [ {
      name: 'backpack',
      tags: [ 'school', 'travel', 'kids' ]
    } ],
    score: 1.2907354831695557
  }
]

Consulta de faceta

A query a seguir pesquisa itens marcados como school com uma preferência por itens chamados backpack. Ele solicita informações sobre facetas no campo purchaseMethod.

1db.sales.aggregate({
2  "$searchMeta": {
3    "facet": {
4      "operator": {
5        "embeddedDocument": {
6          "path": "items",
7          "operator": {
8            "compound": {
9              "must": [
10                {
11                  "text": {
12                    "path": "items.tags",
13                    "query": "school"
14                  }
15                }
16              ],
17              "should": [
18                {
19                  "text": {
20                    "path": "items.name",
21                    "query": "backpack"
22                  }
23                }
24              ]
25            }
26          }
27        }
28      },
29      "facets": {
30        "purchaseMethodFacet": {
31          "type": "string",
32          "path": "purchaseMethod"
33        }
34      }
35    }
36  }
37})
[
  {
    count: { lowerBound: Long("2309") },
    facet: {
      purchaseMethodFacet: {
        buckets: [
          { _id: 'In store', count: Long("2751") },
          { _id: 'Online', count: Long("1535") },
          { _id: 'Phone', count: Long("578") }
        ]
      }
    }
  }
]

Query e classificação

A query a seguir pesquisa por itens chamados laptop e classifica os resultados pelo campo items.tags. A query inclui um estágio $limit para limitar a saída a 5 documentos e um estágio $project para:

  • Excluir todos os campos, exceto items.name e items.tags

  • Adicione um campo chamado score

1db.sales.aggregate({
2  "$search": {
3    "embeddedDocument": {
4      "path": "items",
5      "operator": {
6        "text": {
7          "path": "items.name",
8          "query": "laptop"
9        }
10      }
11    },
12    "sort": {
13      "items.tags": 1
14    }
15  }
16},
17{
18  "$limit": 5
19},
20{
21  "$project": {
22    "_id": 0,
23    "items.name": 1,
24    "items.tags": 1,
25    "score": { "$meta": "searchScore" }
26  }
27})
1[
2  {
3    items: [
4      { name: 'envelopes',  tags: [ 'stationary', 'office', 'general' ] },
5      { name: 'binder', tags: [ 'school', 'general', 'organization' ] },
6      { name: 'notepad', tags: [ 'office', 'writing', 'school' ] },
7      { name: 'laptop', tags: [ 'electronics', 'school', 'office' ] },
8      { name: 'notepad', tags: [ 'office', 'writing', 'school' ] },
9      { name: 'printer paper', tags: [ 'office', 'stationary' ] },
10      { name: 'backpack', tags: [ 'school', 'travel', 'kids' ] },
11      { name: 'pens', tags: [ 'writing', 'office', 'school', 'stationary' ] },
12      { name: 'envelopes', tags: [ 'stationary', 'office', 'general' ] }
13    ],
14    score: 1.168686032295227
15  },
16  {
17    items: [
18      { name: 'notepad', tags: [ 'office', 'writing', 'school' ] },
19      { name: 'binder', tags: [ 'school', 'general', 'organization' ] },
20      { name: 'notepad', tags: [ 'office', 'writing', 'school' ] },
21      { name: 'pens', tags: [ 'writing', 'office', 'school', 'stationary' ] },
22      { name: 'printer paper', tags: [ 'office', 'stationary' ] },
23      { name: 'pens', tags: [ 'writing', 'office', 'school', 'stationary' ] },
24      { name: 'notepad', tags: [ 'office', 'writing', 'school' ] },
25      { name: 'backpack', tags: [ 'school', 'travel', 'kids' ] },
26      { name: 'laptop', tags: [ 'electronics', 'school', 'office' ] }
27    ],
28    score: 1.168686032295227
29  },
30  {
31    items: [
32      { name: 'backpack', tags: [ 'school', 'travel', 'kids' ] },
33      { name: 'notepad', tags: [ 'office', 'writing', 'school' ] },
34      { name: 'binder', tags: [ 'school', 'general', 'organization' ] },
35      { name: 'pens', tags: [ 'writing', 'office', 'school', 'stationary' ] },
36      { name: 'notepad', tags: [ 'office', 'writing', 'school' ] },
37      { name: 'envelopes', tags: [ 'stationary', 'office', 'general' ] },
38      { name: 'laptop', tags: [ 'electronics', 'school', 'office' ] }
39    ],
40    score: 1.168686032295227
41  },
42  {
43    items: [
44      { name: 'laptop', tags: [ 'electronics', 'school', 'office' ] },
45      { name: 'binder', tags: [ 'school', 'general', 'organization' ] },
46      { name: 'binder', tags: [ 'school', 'general', 'organization' ] },
47      { name: 'backpack', tags: [ 'school', 'travel', 'kids' ] },
48      { name: 'notepad', tags: [ 'office', 'writing', 'school' ] },
49      { name: 'printer paper', tags: [ 'office', 'stationary' ] },
50      { name: 'pens', tags: [ 'writing', 'office', 'school', 'stationary' ] },
51      { name: 'notepad', tags: [ 'office', 'writing', 'school' ] },
52      { name: 'pens', tags: [ 'writing', 'office', 'school', 'stationary' ] },
53      { name: 'notepad', tags: [ 'office', 'writing', 'school' ] }
54    ],
55    score: 1.168686032295227
56  },
57  {
58    items: [
59      { name: 'envelopes', tags: [ 'stationary', 'office', 'general' ] },
60      { name: 'notepad', tags: [ 'office', 'writing', 'school' ] },
61      { name: 'notepad', tags: [ 'office', 'writing', 'school' ] },
62      { name: 'backpack', tags: [ 'school', 'travel', 'kids' ] },
63      { name: 'envelopes', tags: [ 'stationary', 'office', 'general' ] },
64      { name: 'pens', tags: [ 'writing', 'office', 'school', 'stationary' ] },
65      { name: 'binder', tags: [ 'school', 'general', 'organization' ] },
66      { name: 'laptop', tags: [ 'electronics', 'school', 'office' ] },
67      { name: 'printer paper', tags: [ 'office', 'stationary' ] },
68      { name: 'binder', tags: [ 'school', 'general', 'organization' ] }
69    ],
70    score: 1.168686032295227
71  }
72]

Consultar apenas documentos incorporados correspondentes

A query a seguir retorna somente os documentos aninhados que correspondem à query. A query usa as cláusulas do operador composto MongoDB Search no estágio $search para encontrar documentos correspondentes e, em seguida, os operadores de agregação no estágio $project para retornar somente os documentos incorporados correspondentes. Especificamente, a query especifica os seguintes estágios de pipeline:

$search

Especifica os seguintes critérios na cláusula must do operador composto:

  • Verifique se o campo items.price existe na coleção.

  • Pesquise os itens com a tag school no campo items.tags .

  • Faça a correspondência somente se o valor for maior que 2 para o campo items.quantity .

$limit

Limita a saída a 5 documentos.

$project

Execute as seguintes ações:

  • Exclua o campo _id e inclua somente os campos items e storeLocation.

  • Use $filter para retornar apenas os elementos da matriz de entrada items que correspondem à condição especificada com o operador $and. O operador and usa os seguintes operadores:

    • $ifNull para determinar se items.price contém valores nulos e substituir valores nulos, se presentes, pela expressão de substituição false.

    • $gt para verificar se a quantidade é maior que 2.

    • $in para verificar se office existe na array tags.

1db.sales.aggregate(
2  {
3    "$search": {
4      "embeddedDocument": {
5        "path": "items",
6        "operator": {
7          "compound": {
8            "must": [
9              {
10                "range": {
11                  "path": "items.quantity",
12                  "gt": 2
13                }
14              },
15              {
16                "exists": {
17                  "path": "items.price"
18                }
19              },
20              {
21                "text": {
22                  "path": "items.tags",
23                  "query": "school"
24                }
25              }
26            ]
27          }
28        }
29      }
30    }
31  },
32  {
33    "$limit": 2
34  },
35  {
36    "$project": {
37      "_id": 0,
38      "storeLocation": 1,
39      "items": {
40        "$filter": {
41          "input": "$items",
42          "cond": {
43            "$and": [
44              {
45                "$ifNull": [
46                  "$$this.price", "false"
47                ]
48              },
49              {
50                "$gt": [
51                  "$$this.quantity", 2
52                ]
53              },
54              {
55                "$in": [
56                  "office", "$$this.tags"
57                ]
58              }
59            ]
60          }
61        }
62      }
63    }
64  }
65)
1[
2  {
3    storeLocation: 'Austin',
4    items: [
5      {
6        name: 'laptop',
7        tags: [ 'electronics', 'school', 'office' ],
8        price: Decimal128('753.04'),
9        quantity: 3
10      },
11      {
12        name: 'pens',
13        tags: [ 'writing', 'office', 'school', 'stationary' ],
14        price: Decimal128('19.09'),
15        quantity: 4
16      },
17      {
18        name: 'notepad',
19        tags: [ 'office', 'writing', 'school' ],
20        price: Decimal128('30.23'),
21        quantity: 5
22      },
23      {
24        name: 'pens',
25        tags: [ 'writing', 'office', 'school', 'stationary' ],
26        price: Decimal128('20.05'),
27        quantity: 4
28      },
29      {
30        name: 'notepad',
31        tags: [ 'office', 'writing', 'school' ],
32        price: Decimal128('22.08'),
33        quantity: 3
34      },
35      {
36        name: 'notepad',
37        tags: [ 'office', 'writing', 'school' ],
38        price: Decimal128('21.67'),
39        quantity: 4
40      }
41    ]
42  },
43  {
44    storeLocation: 'Austin',
45    items: [
46      {
47        name: 'notepad',
48        tags: [ 'office', 'writing', 'school' ],
49        price: Decimal128('24.16'),
50        quantity: 5
51      },
52      {
53        name: 'notepad',
54        tags: [ 'office', 'writing', 'school' ],
55        price: Decimal128('28.04'),
56        quantity: 5
57      },
58      {
59        name: 'notepad',
60        tags: [ 'office', 'writing', 'school' ],
61        price: Decimal128('21.42'),
62        quantity: 5
63      },
64      {
65        name: 'laptop',
66        tags: [ 'electronics', 'school', 'office' ],
67        price: Decimal128('1540.63'),
68        quantity: 3
69      },
70      {
71        name: 'pens',
72        tags: [ 'writing', 'office', 'school', 'stationary' ],
73        price: Decimal128('29.43'),
74        quantity: 5
75      },
76      {
77        name: 'pens',
78        tags: [ 'writing', 'office', 'school', 'stationary' ],
79        price: Decimal128('28.48'),
80        quantity: 5
81      }
82    ]
83  }
84]

Saiba mais

Para saber mais, consulte Como executar queries de pesquisa do MongoDB em campos em documentos incorporados.

Voltar

composto

Próximo

é igual a

Nesta página