/ /

Operadores y coleccionistas

Docs Home

/ /

Referencia de query

Operadores y coleccionistas

Operadores y coleccionistas

`compound` Operador

Definición

compound: El operador compound combina dos o más operadores en una sola query. Cada elemento de una compound query se denomina cláusula, y cada cláusula consta de una o más subconsultas. MongoDB Search proporciona una plantilla de query compuesta de muestra con orientación.

Sintaxis

compound tiene la siguiente sintaxis:

1 {
2   $search: {
3     "index": <index name>, // optional, defaults to "default"
4     "compound": {
5       <must | mustNot | should | filter>: [ { <clauses> } ],
6       "score": <options>,
7       "doesNotAffect": "<facet-to-exclude>" | [<array-of-facets>]
8     }
9   }
10 }

Cada cláusula must, mustNot, should y filter contiene un arreglo de subcláusulas. Utiliza la sintaxis de arreglos incluso si el arreglo contiene solo una subcláusula. Ver el ejemplos en esta página.

opciones

compound utiliza los siguientes términos para construir una query:

must

Cláusulas que deben coincidir para que un documento se incluya en los resultados. La puntuación devuelta es la suma de las puntuaciones de todas las subconsultas en la cláusula.

Se corresponde con el operador booleano AND.

mustNot

Cláusulas que no deben coincidir para que un documento se incluya en los resultados. Las cláusulas mustNot no contribuyen a la puntuación de un documento devuelto.

Se corresponde con el operador booleano AND NOT.

should

Cláusulas que prefieres que coincidan en los documentos que se incluyen en los resultados. Los documentos que contienen una coincidencia para una cláusula should tienen puntuaciones más altas que los documentos que no contienen una cláusula should. La puntuación devuelta es la suma de las puntuaciones de todas las subconsultas en la cláusula.

Si utiliza más de una cláusula should, puede utilizar la opción minimumShouldMatch para especificar un número mínimo de cláusulas should que deben coincidir para incluir un documento en los resultados. El valor de las minimumShouldMatch debe ser menor o igual que el número de should cláusulas en la query. Si se omite, la opción minimumShouldMatch se establece por defecto en 0.

Ver un ejemplo.

Se corresponde con el operador booleano OR.

Si solo usas la cláusula should dentro de una query compuesta, el operador compound trata el arreglo de las queries de la cláusula should como un OR lógico. MongoDB Search debe encontrar una coincidencia para al menos un criterio should para devolver cualquier resultado. Cuando especifica varios criterios de la cláusula should con la opción minimumShouldMatch establecer en 0, MongoDB Search trata minimumShouldMatch como 1 y debe coincidir con al menos un criterio para devolver resultados.

filter

Cláusulas que deben coincidir para que un documento se incluya en los resultados. Las cláusulas filter no contribuyen a la puntuación de un documento devuelto.

Por ejemplo, puedes sustituir la etapa $match por la etapa $search utilizando la opción filter del operador compound. La siguiente $match etapa filtra documentos con un valor específico para el campo role:

$match: {
    "role": { "$in": [ "CLIENT", "PROFESSIONAL" ] }
}

En vez de eso, puedes usar la compound opción de filter operador:

$search: {
  "compound": {
    "filter": [{
      "queryString": {
        "defaultPath": "role",
        "query": "CLIENT OR PROFESSIONAL"
      }
    }]
  }
}

Consulta otro ejemplo de filtro.

score

Modifique la puntuación de toda la cláusula compound. Puedes usar score para aumentar, reemplazar o modificar de otro modo la puntuación. Si no especificas score, la puntuación devuelta es la suma de las puntuaciones de todas las subconsultas en las cláusulas must y should que generaron una coincidencia. Para obtener más información, consulta Comportamiento de puntuación.

doesNotAffect

Faceta o lista de facetas que se excluirán del recálculo de recuento según esta consulta. El valor debe ser uno o más nombres de una faceta definida en $search.facets $searchMeta.facetso. El operador utiliza las facetas especificadas para filtrar documentos que coincidan con esta consulta, pero no recalcula sus recuentos. Para obtener más información, consulte Facetas de selección múltiple.

Uso

Puedes utilizar cualquiera de las cláusulas con cualquier operador de nivel superior, como autocompletar, texto o fragmento, para especificar los criterios de la query.

Para optimizar el rendimiento, coloca operadores sin puntuación como igual, rango, e en en la cláusula filter para evitar operaciones de puntuación innecesarias. Si deseas ejecutar varias operaciones que deben evaluarse como una condición OR, anida una cláusula should dentro del filterde primer nivel.

Ejemplo

[
  {
    $search: {
      index: "default",
      compound: {
        filter: [
          {
            compound: {
              should: [
                {
                  equals: {
                    path: "accommodates",
                    value: 2
                  }
                },
                {
                  range: {
                    path: "pricePerNight",
                    lte: 200
                  }
                }
              ]
            }
          }
        ]
      }
    }
  }
]

Comportamiento de la puntuación

MongoDB Search puntúa los documentos en el conjunto de resultados sumando la puntuación que el documento recibió para cada cláusula individual que generó una coincidencia en el documento. Solo las cláusulas must y should participan en la valoración. El conjunto de resultados está ordenado por puntuación, de mayor a menor.

La siguiente tabla muestra las compound cláusulas que contribuyen y que no contribuyen a la puntuación.

Cláusula	Contribuye a la puntuación
`filter`
`must`
`mustNot`
`should`

Puedes aumentar o reemplazar la puntuación de toda la consulta compuesta con la opción score. Consulta un ejemplo de cómo reemplazar toda la puntuación compuesta en Ejemplo de puntuación compuesta a continuación. Puedes usar la puntuación para aumentar o modificar también la puntuación de cada subconsulta de cada cláusula. Consulta algunos ejemplos de puntuaciones alteradas en cláusulas del operador compound en Modificación de la puntuación.

Ejemplos

Puedes probar los siguientes ejemplos en MongoDB Search Playground o en tu clúster.

Colección de muestra

Los ejemplos de esta página utilizan una colección llamada fruit, que contiene los siguientes documentos:

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 },
8 {
9   "_id" : 2,
10   "type" : "banana",
11   "description" : "Bananas are usually sold in bunches of five or six.",
12   "category" : "nonorganic",
13   "in_stock" : true
14 },
15 {
16   "_id" : 3,
17   "type" : "pear",
18   "description" : "Bosc and Bartlett are the most common varieties of pears.",
19   "category" : "organic",
20   "in_stock" : true
21 }

Índice de muestra

La colección fruit tiene un índice predeterminado con mapeo dinámico que indexa automáticamente todos los campos de la colección y utiliza el analizador estándar por defecto. El analizador standard convierte todas las palabras a minúsculas y omite las palabras vacías comunes ("the", "a", "and",, etc.).

Queries de muestra

Las siguientes consultas demuestran el operador $search compound en las consultas de MongoDB Search.

`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.

➤ Prueba esto en el Playground de MongoDB Search.

`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.

Para esta query, la etapa de pipeline $project excluye todos los campos del documento excepto _id y añade un campo score, que muestra la puntuación de relevancia del documento.

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 }

El documento con _id: 1 obtiene una puntuación más alta porque su campo description contiene la palabra Fuji, satisfaciendo la cláusula should.

➤ Prueba esto en el Playground de MongoDB Search.

La siguiente query también especifica una puntuación de constant de 3 para todos los documentos en los resultados. Para esta query, la etapa de pipeline $project excluye todos los campos de documentos excepto _id y añade un campo score.

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

Ambos documentos reciben la misma puntuación porque la opción constant en la query reemplaza la puntuación de cada documento en el resultado por el número 3.

➤ Prueba esto en el Playground de MongoDB Search.

Ejemplo de minimumShouldMatch

En una query con varias cláusulas should, se 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.

➤ Prueba esto en el Playground de MongoDB Search.

`filter` Ejemplos

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

La siguiente query utiliza las siguientes cláusulas:

must y filter para especificar las condiciones de búsqueda que deben cumplirse.
should para especificar preferencia por documentos que contengan la palabra banana. La cláusula should no incluye la opción minimumShouldMatch. Cuando omitas minimumShouldMatch, se establecerá por defecto en 0.

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 }

El documento devuelto cumple todos los requisitos para su inclusión:

Tanto la cláusula must como la filter coinciden.
El valor minimumShouldMatch no está especificado, por lo que su valor por defecto será 0. Como resultado, la cláusula should falla y aún así devuelve un documento.

➤ Prueba esto en el Playground de MongoDB Search.

Puede reemplazar el $match con $in en sus consultas sobre datos de su clúster con la cláusula filter. La siguiente consulta demuestra cómo utilizar filter en la etapa $search para especificar los términos de búsqueda que deben coincidir. La query también utiliza should para especificar preferencia por documentos que contengan el término varieties. La query incluye la etapa de pipeline $project para realizar lo siguiente:

Exceptuar todos los campos excepto _id y description.
Añada un campo score, que muestra la puntuación de relevancia del documento.

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 ]

Los documentos en el resultado cumplen con todos los requisitos para su inclusión:

Ambos documentos contienen el término apples o bananas que se especificó en la cláusula filter de la query.
Un documento con _id: 1 obtiene una puntuación mayor que un documento con _id: 2 porque contiene el término varieties especificado en la cláusula should de la query.

➤ Prueba esto en el Playground de MongoDB Search.

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 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.

➤ Prueba esto en el Playground de MongoDB Search.

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.

La siguiente query solo devuelve los metadatos en los resultados.

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

La siguiente query devuelve los metadatos y los resultados de búsqueda.

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

Volver

Autocompletar

embeddedDocument

1	{
2	$search: {
3	"index": <index name>, // optional, defaults to "default"
4	"compound": {
5	<must \| mustNot \| should \| filter>: [ { <clauses> } ],
6	"score": <options>,
7	"doesNotAffect": "<facet-to-exclude>" \| [<array-of-facets>]
8	}
9	}
10	}

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	},
8	{
9	"_id" : 2,
10	"type" : "banana",
11	"description" : "Bananas are usually sold in bunches of five or six.",
12	"category" : "nonorganic",
13	"in_stock" : true
14	},
15	{
16	"_id" : 3,
17	"type" : "pear",
18	"description" : "Bosc and Bartlett are the most common varieties of pears.",
19	"category" : "organic",
20	"in_stock" : true
21	}

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

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	]

Definición

Sintaxis

opciones

Uso

Ejemplo

Comportamiento de la puntuación

Ejemplos

Colección de muestra

Índice de muestra

Queries de muestra

must y mustNot Ejemplo

must y should Ejemplo

Ejemplo de minimumShouldMatch

filter Ejemplos

Ejemplo anidado

Ejemplos de metadatos

`must` y `mustNot` Ejemplo

`must` y `should` Ejemplo

`filter` Ejemplos