composto

must e mustNot Exemplo

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.

➤ Experimente isso no Atlas Search Playground.

must e should Exemplo

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

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

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

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

➤ Experimente isso no Atlas Search Playground.

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

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

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.

➤ Experimente isso no Atlas Search Playground.