compound Operador

must y mustNot Ejemplo

El siguiente ejemplo utiliza una combinación de cláusulas must y mustNot para construir una query. La cláusula must utiliza el operador de texto para buscar el término varieties en el campo description. Para que un documento coincida, debe cumplir con la cláusula must. La cláusula mustNot realiza una operación de búsqueda del término apples en el campo description. Para que un documento coincida, no debe cumplir la 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
])

La query anterior devuelve el documento con _id: 3 porque su campo description contiene la palabra varieties y no contiene apples.

➤ Pruebe esto en el patio de búsqueda de MongoDB.

must y should Ejemplo

Las siguientes queries usan must para especificar las condiciones de búsqueda que deben cumplirse y should para especificar la preferencia para los documentos que contienen la palabra 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 } ]

Ejemplo de minimumShouldMatch

En una consulta con múltiples cláusulas should, puede utilizar la opción miniumumShouldMatch para especificar un número mínimo de cláusulas que deben coincidir para devolver un resultado.

La siguiente consulta tiene una cláusula must y dos cláusulas should, con un valor minimumShouldMatch de 1. Un documento debe incluir el término varieties en el campo description y debe incluir Fuji o Golden Delicious en el campo de descripción para ser incluido en el 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
}

El documento con _id: 1 coincide con la cláusula must y la primera de las dos cláusulas should.

➤ Pruebe esto en el patio de búsqueda de MongoDB.

filter Ejemplos

filter se comporta igual que must, excepto que la cláusula filter no se considera en la puntuación de un documento devuelto y, por lo tanto, no afecta el orden de los documentos devueltos.

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
]

Ejemplo anidado

En el siguiente ejemplo se utilizan cláusulas anidadas compound para construir una query. En este ejemplo, la colección fruit tiene un índice en los campos type, category y in_stock, cuyos campos de texto usan el analizador por defecto. La query requiere que los documentos solo cumplan una de las siguientes cláusulas should:

• Contener la palabra apple en el campo type.

• Incluye el término organic en el campo category y el valor true en el 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
}

Los documentos incluidos en los resultados cumplen todos los requisitos para su inclusión:

• El documento con _id: 3 coincide con la cláusula must anidada dentro de la segunda cláusula should.

• El documento con _id: 1 coincide con la primera should cláusula.

➤ Pruebe esto en el patio de búsqueda de MongoDB.

Ejemplos de metadatos

Las siguientes consultas recuperan metadatos para devolver el número de categorías en la colección fruit utilizando la fase de pipeline $searchMeta o la variable $$SEARCHMETA de la fase $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') }
          ]
        }
      }
    }
  }
]