Menu Docs
Página inicial do Docs
/
Atlas
/ / / /

embeddedDocument Operador

Observação

O tipoembeddedDocuments do MongoDB Search , o operadorembeddedDocument e a opção de pontuação do embedded estão na pré-visualização.

Você não pode fazer realces em consultas 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.

Usar o tipo de campo embeddedDocuments pode resultar na indexação de objetos acima desse limite de tamanho de índice, pois cada documento incorporado indexado é contado como um único objeto. Se você criar um índice do MongoDB Search que tenha ou tenha em breve mais de 2.1 bilhões de objetos de índice, use a opção de índice numPartitions para particionar seu índice (suportado somente em sistemas de Nós de Pesquisa) ou fragmentar seu cluster.

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 queries em campos do tipo embeddedDocuments.

embeddedDocument tem a seguinte sintaxe:

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

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 de pesquisa correspondentes. Você pode utilizar a embedded opção de pontuação para configurar as opções de pontuação. Para saber mais, consulte Comportamento de pontuação.

Opcional

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.

    Observação

    Para facetar strings, o MongoDB Search conta as facets da string uma vez para cada documento no conjunto de resultados. Para ver um exemplo desse comportamento, consulte Exemplos.

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

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.

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.

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

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

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

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") }
]
}
}
}
]

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]

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:

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 .

Limita a saída a 5 documentos.

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]

Dica

Para retornar apenas documentos incorporados correspondentes nos resultados, inclua um $filter equivalente para corresponder aos critérios $search no campo do documento incorporado. Para retornar apenas documentos incorporados correspondentes nos resultados do estágio $search, vote a favor desta solicitação no MongoDB Feedback Engine.

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

Voltar

composto

Nesta página