/ /

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

See an example.

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.

For example, you can replace the $match stage with the $search stage using the compound operator filter option. The following $match stage filters for documents with a given value for the field role:

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

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

$search: {
  "compound": {
    "filter": [{
      "in": {
        "path": "role",
        "value": [ "CLIENT", "PROFESSIONAL" ]
      }
    }]
  }
}

See another filter example.

score

Modify the score of the entire compound clause. You can use score to boost, replace, or otherwise alter the score. If you don't specify score, the returned score is the sum of the scores of all the subqueries in the must and should clauses that generated a match. To learn more, see Scoring Behavior.

doesNotAffect

Faceta o lista de facetas que se deben excluir del recálculo del recuento en función de esta query. El valor debe ser uno o más nombres de una faceta definida en $search.facets o $searchMeta.facets. El operador utiliza las facetas especificadas para filtrar documentos que coincidan con esta query, pero no recalcula las cuentas para ellas. Para obtener más información, consulta 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.

To optimize performance, place non-scoring operators such as equals, range, and in in the filter clause to avoid unnecessary scoring operations. If you want to run multiple operations that must be evaluated as an OR condition, nest a should clause within the top-level filter.

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`

You can boost or replace the score of the entire compound query using the score option. For an example of replacing the entire compound score, see Compound Score Example below. You can use score to also boost or alter the score for each subquery in each clause. For some examples of altered scores in compound operator clauses, see Modify the Score.

Ejemplos

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

Colección de muestra

To run the sample queries on this page, create a collection named fruit on your cluster and insert the following documents into the collection:

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

To run the sample queries on this page, create the following MongoDB Search index named default on the fruit sample collection. The index definition configures MongoDB Search to do the following:

Indexe dinámicamente todos los campos de la colección fruit utilizando el analizador estándar por defecto para extraer tokens. El analizador standard convierte todas las palabras a minúsculas y omite las palabras vacías comunes, como "the", "a", "and", etc.
Indexe estáticamente el campo type como el tipo string para admitir querys de operador text y el tipo token para admitir querys de operador equals.

1 {
2   "mappings": {
3     "dynamic": true,
4     "fields": {
5       "type": [
6         { "type": "string" },
7         { "type": "token" }
8       ]
9     }
10   }
11 }

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 del pipeline $project excluye todos los campos del documento excepto _id y agrega 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.

When a $match stage follows a $search stage, you can improve query performance by moving the match conditions into a filter clause within the $search stage. MongoDB Search applies filter conditions during the search instead of re-scanning the result set to run the $match stage.

Consider the following pipeline, which searches the description field for the term varieties and then uses $match with $in to keep only apples and bananas:

1 db.fruit.aggregate([
2   {
3     "$search": {
4       "text": {
5         "query": "varieties",
6         "path": "description"
7       }
8     }
9   },
10   {
11     "$match": {
12       "type": { "$in": [ "apple", "banana" ] }
13     }
14   },
15   {
16     "$project": {
17       "description": 1,
18       "score": { "$meta": "searchScore" }
19     }
20   }
21 ])

1 [
2   {
3     _id: 1,
4     description: 'Apples come in several varieties, including Fuji, Granny Smith, and Honeycrisp.',
5     score: 0.20814445614814758
6   }
7 ]

The following query replaces the $match stage with a filter clause that uses the equals operator on the type field. The $search stage uses the compound operator to combine the following clauses:

must cláusula para que coincida con el término de búsqueda varieties en el campo description
filter cláusula para que coincida con los tipos apple y banana

The $project stage does the following:

Excluye todos los campos excepto _id y description
Añade un campo score que contiene 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         "filter": [{
12           "in": {
13             "path": "type",
14             "value": [ "apple", "banana" ]
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.',
5     score: 0.20814445614814758
6   }
7 ]

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

Ambos documentos tienen un valor type de apple o banana, que se especifica 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.

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	{
2	"mappings": {
3	"dynamic": true,
4	"fields": {
5	"type": [
6	{ "type": "string" },
7	{ "type": "token" }
8	]
9	}
10	}
11	}

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.',
5	score: 0.20814445614814758
6	}
7	]

compound Operador

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

`compound` Operador

`must` y `mustNot` Ejemplo

`must` y `should` Ejemplo

`filter` Ejemplos