compound Operador

must e Exemplo mustNot

O exemplo a seguir usa uma combinação das cláusulas must e mustNot para criar uma query. A cláusula must usa o operador de texto para procurar o termo varieties no campo description . Para que um documento corresponda, ele deve atender à cláusula must . A cláusula mustNot executa uma operação de pesquisa para o termo apples no campo description . Para que um documento corresponda, ele não deve atender à cláusula mustNot .

1
db.fruit.aggregate([
2
  {
3
    "$search": {
4
      "compound": {
5
        "must": [{
6
          "text": {
7
            "query": "varieties",
8
            "path": "description"
9
          }
10
        }],
11
        "mustNot": [{
12
          "text": {
13
            "query": "apples",
14
            "path": "description"
15
          }
16
        }]
17
      }
18
    }
19
  }
20
])

A query acima retorna o documento com _id: 3 porque seu campo description contém a palavra varieties e não contém apples.

➤ Tente fazer isso no playground do MongoDB Search.

must e Exemplo should

As queries a seguir usam must para query as condições de procurar que devem ser atendidas e should para especificar a preferência para documentos que contêm a palavra Fuji.

1
db.fruit.aggregate([
2
  {
3
    "$search": {
4
      "compound": {
5
        "must": [{
6
          "text": {
7
            "query": "varieties",
8
            "path": "description"
9
          }
10
        }],
11
        "should": [{
12
          "text": {
13
            "query": "Fuji",
14
            "path": "description"
15
          }
16
        }]
17
      }
18
    }
19
  },
20
  {
21
    "$project": {
22
      "score": { "$meta": "searchScore" }
23
    }
24
  }
25
])

{ "_id" : 1, "score" : 0.6425117254257202 }
{ "_id" : 3, "score" : 0.21649497747421265 }

1
db.fruit.aggregate([
2
  {
3
    "$search": {
4
      "compound": {
5
        "must": [{
6
          "text": {
7
            "query": "varieties",
8
            "path": "description"
9
          }
10
        }],
11
        "should": [{
12
          "text": {
13
            "query": "Fuji",
14
            "path": "description"
15
          }
16
        }],
17
        "score": { "constant": { "value": 3 } }
18
      }
19
    }
20
  },
21
  {
22
    "$project": {
23
      "score": { "$meta": "searchScore" }
24
    }
25
  }
26
])

[ { _id: 1, score: 3 }, { _id: 3, score: 3 } ]

exemplo MinimumShouldMatch

Em uma query com múltiplas cláusulas do should, você pode utilizar a opção miniumumShouldMatch para especificar um número mínimo de cláusulas que deve corresponder para retornar um resultado.

A seguinte query tem uma cláusula must e duas cláusulas should, com um valor minimumShouldMatch de 1. Um documento deve incluir o termo varieties no campo description e deve incluir Fuji ou Golden Delicious no campo de descrição para ser incluído no conjunto de resultados.

1
db.fruit.aggregate([
2
  {
3
    $search: {
4
      "compound": {
5
        "must": [{
6
          "text": {
7
             "query": "varieties",
8
             "path": "description"
9
          }
10
        }],
11
        "should": [{
12
          "text": {
13
            "query": "Fuji",
14
            "path": "description"
15
          }
16
        },
17
        {
18
          "text": {
19
            "query": "Golden Delicious",
20
            "path": "description"
21
          }
22
        }],
23
        "minimumShouldMatch": 1
24
      }
25
    }
26
  }
27
])

1
{
2
  "_id" : 1,
3
  "type" : "apple",
4
  "description" : "Apples come in several varieties, including Fuji, Granny Smith, and Honeycrisp.",
5
  "category" : "nonorganic",
6
  "in_stock" : false
7
}

O documento com _id: 1 corresponde à cláusula must e à primeira das duas cláusulas should.

➤ Tente fazer isso no playground do MongoDB Search.

filter Exemplos

filter comporta-se da mesma forma que must, exceto pelo fato de que a cláusula filter não é considerada na pontuação de um documento retornado e, portanto, não afeta a ordem dos documentos retornados.

1
db.fruit.aggregate([
2
  {
3
    "$search": {
4
      "compound": {
5
        "must": [{
6
          "text": {
7
            "query": "varieties",
8
            "path": "description"
9
          }
10
        }],
11
        "should": [{
12
          "text": {
13
            "query": "banana",
14
            "path": "description"
15
          }
16
        }],
17
        "filter": [{
18
          "text": {
19
            "query": "granny",
20
            "path": "description"
21
          }
22
        }]
23
      }
24
    }
25
  }
26
])

1
{
2
  "_id" : 1,
3
  "type" : "apple",
4
  "description" : "Apples come in several varieties, including Fuji, Granny Smith, and Honeycrisp.",
5
  "category" : "nonorganic",
6
  "in_stock" : false
7
}

1
db.fruit.aggregate([
2
  {
3
    "$search": {
4
      "compound": {
5
        "filter": [{
6
          "text": {
7
            "query": ["apples", "bananas"],
8
            "path": "description"
9
          }
10
        }],
11
        "should": [{
12
          "text": {
13
            "query": "varieties",
14
            "path": "description"
15
          }
16
        }]
17
      }
18
    }
19
  },
20
  {
21
    "$project": {
22
      "description": 1,
23
      "score": { "$meta": "searchScore" }
24
    }
25
  }
26
])

1
[
2
  {
3
    _id: 1,
4
    description: 'Apples come in several varieties, including Fuji, Granny Smith, and Honeycrisp. The most popular varieties are McIntosh, Gala, and Granny Smith.',
5
    score: 0.36074575781822205
6
  },
7
  {
8
    _id: 2,
9
    description: 'Bananas are usually sold in bunches of five or six.',
10
    score: 0
11
  }
12
]

Exemplo aninhado

O exemplo seguinte utiliza cláusulas compound aninhadas para construir uma query. Neste exemplo, a collection fruit tem um índice nos campos type, category e in_stock, cujos campos de texto usam o analyzer padrão. A query exige que os documentos satisfaçam apenas uma das seguintes cláusulas should:

• Contenha a palavra apple no campo type.

• Contém o termo organic no campo category e o valor true no campo in_stock .

1
db.fruit.aggregate([
2
  {
3
    $search: {
4
      "compound": {
5
        "should": [
6
          {
7
            "text": {
8
              "query": "apple",
9
              "path": "type"
10
            }
11
          },
12
          {
13
            "compound": {
14
              "must": [
15
                {
16
                  "text": {
17
                    "query": "organic",
18
                    "path": "category"
19
                  }
20
                },
21
                {
22
                  "equals": {
23
                    "value": true,
24
                    "path": "in_stock"
25
                  }
26
                }
27
              ]
28
            }
29
          }
30
        ],
31
        "minimumShouldMatch": 1
32
      }
33
    }
34
  }
35
])

1
{
2
  "_id" : 3,
3
  "type" : "pear",
4
  "description" : "Bosc and Bartlett are the most common varieties of pears.",
5
  "category" : "organic",
6
  "in_stock" : true
7
}
8
{
9
  "_id" : 1,
10
  "type" : "apple",
11
  "description" : "Apples come in several varieties, including Fuji, Granny Smith, and Honeycrisp.",
12
  "category" : "nonorganic",
13
  "in_stock" : false
14
}

Os documentos dos resultados atendem a todos os requisitos de inclusão:

• O documento com _id: 3 corresponde à cláusula must aninhada dentro da segunda cláusula should.

• O documento com _id: 1 corresponde à primeira cláusula should.

➤ Tente fazer isso no playground do MongoDB Search.

Exemplos de metadados

As consultas a seguir recuperam metadados para retornar o número de categorias na coleção fruit usando o estágio de pipeline $searchMeta ou a variável $$SEARCHMETA do estágio $search.

db.fruit.aggregate([
  {
    "$searchMeta": {
      "facet": {
        "operator": {
          "compound": {
            "must": [{
              "text": {
                "query": "varieties",
                "path": "description"
              }
            }],
            "should": [{
              "text": {
                "query": "Fuji",
                "path": "description"
              }
            }]
          }
        },
        "facets": {
          "categoryFacet": {
            "type": "string",
            "path": "category"
          }
        }
      }
    }
  }
])

[
  {
    count: { lowerBound: Long('2') },
    facet: {
      categoryFacet: {
        buckets: [
          { _id: 'nonorganic', count: Long('1') },
          { _id: 'organic', count: Long('1') }
        ]
      }
    }
  }
]

db.fruit.aggregate([
  {
    "$search": {
      "facet": {
        "operator": {
          "compound": {
            "must": [{
              "text": {
                "query": "varieties",
                "path": "description"
              }
            }],
            "should": [{
              "text": {
                "query": "Fuji",
                "path": "description"
              }
            }]
          }
        },
        "facets": {
          "categoryFacet": {
            "type": "string",
            "path": "category"
          }
        }
      }
    }
  },
  { "$limit": 2 },
  {
    "$facet": {
      "docs": [
        { "$project":
          {
            "type": 1,
            "description": 1
          }
        }
      ],
      "meta": [
        {"$replaceWith": "$$SEARCH_META"},
        {"$limit": 1}
      ]
    }
  },
  {
    "$set": {
      "meta": {
        "$arrayElemAt": ["$meta", 0]
      }
    }
  }
])

[
  {
    docs: [
      {
        _id: 1,
        type: 'apple',
        description: 'Apples come in several varieties, including Fuji, Granny Smith, and Honeycrisp.'
      },
      {
        _id: 3,
        type: 'pear',
        description: 'Bosc and Bartlett are the most common varieties of pears.'
      }
    ],
    meta: {
      count: { lowerBound: Long('2') },
      facet: {
        categoryFacet: {
          buckets: [
            { _id: 'nonorganic', count: Long('1') },
            { _id: 'organic', count: Long('1') }
          ]
        }
      }
    }
  }
]