Docs Menu
Docs Home
/ /
Operadores y coleccionistas
Docs Home
/ /
Referencia de query
/
Operadores y coleccionistas
Docs Home
/
Desarrollo
/
Buscar
/
Query e índices
/
Referencia de query
/
Operadores y coleccionistas

embeddedDocument Operador

Nota

La búsqueda de MongoDB tipo de documentos incrustados, El operador embeddedDocument y la opción de puntuación están en vista embedded previa.

Definición

embeddedDocument

El embeddedDocument operador es similar al operador $elemMatch. Restringe la satisfacción de múltiples predicados de consulta desde un único elemento de una matriz de documentos incrustados. embeddedDocument solo se puede usar para consultas sobre campos del tipo embeddedDocuments.

Sintaxis

embeddedDocument tiene la siguiente sintaxis:

{
  "embeddedDocument": {
    "path": "<path-to-field>",
    "operator": { <operator-specification> },
    "score": { <score-options> }
  }
}

opciones

embeddedDocument utiliza las siguientes opciones para construir una consulta:

Campo
Tipo
Descripción
Necesidad

operator

Objeto

Operador que se utiliza para consultar cada documento de la matriz que se especifica path en. El operador moreLikeThis no es compatible.

Requerido

path

string

Campo de tipo embeddedDocuments indexado para la búsqueda. El campo especificado debe ser un elemento principal para todos los operadores y campos especificados con la operator opción.

Requerido

score

Objeto

Puntuación para asignar a los resultados de búsqueda coincidentes. Puede usar la embedded opción de puntuación para configurar las opciones de puntuación. Para obtener más información, consulte Comportamiento de la puntuación.

Opcional

embeddedDocument Limitaciones del operador

No se puede utilizar resaltar en consultas dentro del embeddedDocument operador.

Nota

MongoDB Search deja de replicar cambios para índices mayores a 2,100,000,000 objetos de índice por partición, en un conjunto de réplicas o un único fragmento, donde cada documento principal incrustado e indexado cuenta como un único objeto. Superar este límite puede generar resultados de consulta obsoletos.

Usar el tipo de campo embeddedDocuments puede hacer que la indexación de objetos supere este límite de tamaño de índice, porque cada documento incrustado indexado se cuenta como un solo objeto. Si se crea un índice de MongoDB Search que tiene o tendrá más de 2.1 mil millones de objetos de índice, se debe usar la opción de índice numPartitions para particionar el índice (compatible solo con implementaciones de nodos de búsqueda) o particionar el clúster.

Comportamiento

Al consultar documentos incrustados en matrices mediante el operador embeddedDocument, MongoDB Search evalúa y puntúa los predicados de consulta del operador en diferentes etapas de la ejecución de la consulta. MongoDB Search:

  1. Evalúa cada documento incrustado en la matriz de forma independiente.

  2. Combina las puntuaciones de los resultados coincidentes según lo configurado utilizando la opción embedded, o puntúa sumando las puntuaciones de los resultados coincidentes si no se especifica una opción de puntuación de embedded.

  3. Une los resultados coincidentes con el documento principal si se especifican otros predicados de consulta a través del compuesto.

Comportamiento de puntuación

De forma predeterminada, embeddedDocument el operador utiliza la estrategia de agregaciónsum predeterminada,, para combinar las puntuaciones de coincidencias de documentos incrustados. La embeddedDocument score opción del operador permite anular la opción predeterminada y configurar la puntuación de los resultados coincidentes mediante la opción.embedded

Tip

Puntúe los documentos en los resultados

Comportamiento de clasificación

Para ordenar los documentos principales por un campo de documento incrustado, debe hacer lo siguiente:

  • Indexa los padres del campo secundario del documento incrustado como el tipo de documento.

  • Indexe el campo secundario con valores de cadena dentro del documento incrustado como tipo de token. Para los campos secundarios con valores numéricos y de fecha, habilite la asignación dinámica para indexarlos automáticamente.

MongoDB Search ordena solo los documentos principales. No ordena los campos secundarios dentro de una matriz de documentos. Para ver un ejemplo, consulte Ejemplo de ordenación.

Destacando

Puede resaltar campos si estos están indexados bajo un campo principal de tipo documento para los predicados de consulta especificados dentro del embeddedDocument operador. Para ver un ejemplo, consulte el tutorial.

Para obtener más información sobre las embeddedDocument limitaciones del operador, consulte embeddedDocument Limitaciones del operador.

Ejemplos

Los siguientes ejemplos utilizan la sample_supplies.sales colección en el conjunto de datos de muestra.

Definición del índice

Estas consultas de muestra utilizan la siguiente definición de índice en la colección:

{
  "mappings": {
    "dynamic": true,
    "fields": {
      "items": [
        {
          "dynamic": true,
          "type": "embeddedDocuments"
        },
        {
          "dynamic": true,
          "fields": {
            "tags": {
              "type": "token"
            }
          },
          "type": "document"
        }
      ],
      "purchaseMethod": {
        "type": "token"
      }
    }
  }
}

Consulta básica

La siguiente consulta busca en la colección elementos etiquetados como,school con preferencia por los elementos backpack llamados. MongoDB Search puntúa los resultados en orden descendente según la puntuación promedio (media aritmética) de todos los documentos incrustados coincidentes. La consulta incluye una etapa para limitar la salida $limit a 5 documentos y una etapa $project para:

  • Excluir todos los campos excepto los campos items.name y items.tags

  • Agregue un campo llamado score

1db.sales.aggregate({
2  "$search": {
3    "embeddedDocument": {
4      "path": "items",
5      "operator": {
6        "compound": {
7          "must": [{
8            "text": {
9              "path": "items.tags",
10              "query": "school"
11            }
12          }],
13          "should": [{
14            "text": {
15              "path": "items.name",
16              "query": "backpack"
17            }
18          }]
19        }
20      },
21      "score": {
22        "embedded": {
23          "aggregate": "mean"
24        }
25      }
26    }
27  }
28},
29{
30  $limit: 5
31},
32{
33  $project: {
34    "_id": 0,
35    "items.name": 1,
36    "items.tags": 1,
37    "score": { $meta: "searchScore" }
38  }
39})
[
  {
    items: [ {
      name: 'backpack',
      tags: [ 'school', 'travel', 'kids' ]
    } ],
    score: 1.2907354831695557
  },
  {
    items: [ {
      name: 'envelopes',
      tags: [ 'stationary', 'office', 'general' ]
    },
    {
      name: 'printer paper',
      tags: [ 'office', 'stationary' ]
    },
    {
      name: 'backpack',
      tags: [ 'school', 'travel', 'kids' ]
    } ],
    score: 1.2907354831695557
  },
  {
    items: [ {
      name: 'backpack',
      tags: [ 'school', 'travel', 'kids' ]
    } ],
    score: 1.2907354831695557
  },
  {
    items: [ {
      name: 'backpack',
      tags: [ 'school', 'travel', 'kids' ]
    } ],
    score: 1.2907354831695557
  },
  {
    items: [ {
      name: 'backpack',
      tags: [ 'school', 'travel', 'kids' ]
    } ],
    score: 1.2907354831695557
  }
]

Consulta de facetas

La siguiente consulta busca elementos etiquetados como school con preferencia por los elementos llamados backpack. Solicita información de faceta en el campo purchaseMethod.

1db.sales.aggregate({
2  "$searchMeta": {
3    "facet": {
4      "operator": {
5        "embeddedDocument": {
6          "path": "items",
7          "operator": {
8            "compound": {
9              "must": [
10                {
11                  "text": {
12                    "path": "items.tags",
13                    "query": "school"
14                  }
15                }
16              ],
17              "should": [
18                {
19                  "text": {
20                    "path": "items.name",
21                    "query": "backpack"
22                  }
23                }
24              ]
25            }
26          }
27        }
28      },
29      "facets": {
30        "purchaseMethodFacet": {
31          "type": "string",
32          "path": "purchaseMethod"
33        }
34      }
35    }
36  }
37})
[
  {
    count: { lowerBound: Long("2309") },
    facet: {
      purchaseMethodFacet: {
        buckets: [
          { _id: 'In store', count: Long("2751") },
          { _id: 'Online', count: Long("1535") },
          { _id: 'Phone', count: Long("578") }
        ]
      }
    }
  }
]

Consulta y ordenación

La siguiente consulta busca elementos llamados laptop y ordena los resultados por el items.tags campo. La consulta incluye una etapa para limitar la salida $limit a 5 documentos y una etapa $project para:

  • Excluir todos los campos excepto items.name y items.tags

  • Agregue un campo llamado score

1db.sales.aggregate({
2  "$search": {
3    "embeddedDocument": {
4      "path": "items",
5      "operator": {
6        "text": {
7          "path": "items.name",
8          "query": "laptop"
9        }
10      }
11    },
12    "sort": {
13      "items.tags": 1
14    }
15  }
16},
17{
18  "$limit": 5
19},
20{
21  "$project": {
22    "_id": 0,
23    "items.name": 1,
24    "items.tags": 1,
25    "score": { "$meta": "searchScore" }
26  }
27})
1[
2  {
3    items: [
4      { name: 'envelopes',  tags: [ 'stationary', 'office', 'general' ] },
5      { name: 'binder', tags: [ 'school', 'general', 'organization' ] },
6      { name: 'notepad', tags: [ 'office', 'writing', 'school' ] },
7      { name: 'laptop', tags: [ 'electronics', 'school', 'office' ] },
8      { name: 'notepad', tags: [ 'office', 'writing', 'school' ] },
9      { name: 'printer paper', tags: [ 'office', 'stationary' ] },
10      { name: 'backpack', tags: [ 'school', 'travel', 'kids' ] },
11      { name: 'pens', tags: [ 'writing', 'office', 'school', 'stationary' ] },
12      { name: 'envelopes', tags: [ 'stationary', 'office', 'general' ] }
13    ],
14    score: 1.168686032295227
15  },
16  {
17    items: [
18      { name: 'notepad', tags: [ 'office', 'writing', 'school' ] },
19      { name: 'binder', tags: [ 'school', 'general', 'organization' ] },
20      { name: 'notepad', tags: [ 'office', 'writing', 'school' ] },
21      { name: 'pens', tags: [ 'writing', 'office', 'school', 'stationary' ] },
22      { name: 'printer paper', tags: [ 'office', 'stationary' ] },
23      { name: 'pens', tags: [ 'writing', 'office', 'school', 'stationary' ] },
24      { name: 'notepad', tags: [ 'office', 'writing', 'school' ] },
25      { name: 'backpack', tags: [ 'school', 'travel', 'kids' ] },
26      { name: 'laptop', tags: [ 'electronics', 'school', 'office' ] }
27    ],
28    score: 1.168686032295227
29  },
30  {
31    items: [
32      { name: 'backpack', tags: [ 'school', 'travel', 'kids' ] },
33      { name: 'notepad', tags: [ 'office', 'writing', 'school' ] },
34      { name: 'binder', tags: [ 'school', 'general', 'organization' ] },
35      { name: 'pens', tags: [ 'writing', 'office', 'school', 'stationary' ] },
36      { name: 'notepad', tags: [ 'office', 'writing', 'school' ] },
37      { name: 'envelopes', tags: [ 'stationary', 'office', 'general' ] },
38      { name: 'laptop', tags: [ 'electronics', 'school', 'office' ] }
39    ],
40    score: 1.168686032295227
41  },
42  {
43    items: [
44      { name: 'laptop', tags: [ 'electronics', 'school', 'office' ] },
45      { name: 'binder', tags: [ 'school', 'general', 'organization' ] },
46      { name: 'binder', tags: [ 'school', 'general', 'organization' ] },
47      { name: 'backpack', tags: [ 'school', 'travel', 'kids' ] },
48      { name: 'notepad', tags: [ 'office', 'writing', 'school' ] },
49      { name: 'printer paper', tags: [ 'office', 'stationary' ] },
50      { name: 'pens', tags: [ 'writing', 'office', 'school', 'stationary' ] },
51      { name: 'notepad', tags: [ 'office', 'writing', 'school' ] },
52      { name: 'pens', tags: [ 'writing', 'office', 'school', 'stationary' ] },
53      { name: 'notepad', tags: [ 'office', 'writing', 'school' ] }
54    ],
55    score: 1.168686032295227
56  },
57  {
58    items: [
59      { name: 'envelopes', tags: [ 'stationary', 'office', 'general' ] },
60      { name: 'notepad', tags: [ 'office', 'writing', 'school' ] },
61      { name: 'notepad', tags: [ 'office', 'writing', 'school' ] },
62      { name: 'backpack', tags: [ 'school', 'travel', 'kids' ] },
63      { name: 'envelopes', tags: [ 'stationary', 'office', 'general' ] },
64      { name: 'pens', tags: [ 'writing', 'office', 'school', 'stationary' ] },
65      { name: 'binder', tags: [ 'school', 'general', 'organization' ] },
66      { name: 'laptop', tags: [ 'electronics', 'school', 'office' ] },
67      { name: 'printer paper', tags: [ 'office', 'stationary' ] },
68      { name: 'binder', tags: [ 'school', 'general', 'organization' ] }
69    ],
70    score: 1.168686032295227
71  }
72]

Consulta solo para documentos incrustados coincidentes

La siguiente consulta devuelve únicamente los documentos anidados que coinciden con la consulta. La consulta utiliza las cláusulas de operador compuesto de MongoDB Search en la $search etapa para encontrar los documentos coincidentes y, posteriormente, los operadores de agregación en la $project etapa para devolver únicamente los documentos incrustados coincidentes. En concreto, la consulta especifica las siguientes etapas de la canalización:

$search

Especifica los siguientes criterios en la cláusula del operador must compuesto:

  • Comprueba si el campo items.price existe en la colección.

  • Busque los elementos etiquetados como school en el campo items.tags.

  • Coincide sólo si el valor es mayor que 2 para el campo items.quantity.

$limit

Limita la salida a 5 documentos.

$project

Realice las siguientes acciones:

  • Excluye el campo _id e incluye solo los campos items y storeLocation.

  • Utilice para devolver solo los elementos de $filter la items matriz de entrada que cumplan la condición especificada con $and el operador. El and operador utiliza los siguientes operadores:

    • $ifNull para determinar si items.price contiene valores nulos y reemplazar los valores nulos, si están presentes, con la expresión de false reemplazo.

    • $gt para comprobar si la cantidad es mayor que 2.

    • $in para comprobar si office existe en la tags matriz.

1db.sales.aggregate(
2  {
3    "$search": {
4      "embeddedDocument": {
5        "path": "items",
6        "operator": {
7          "compound": {
8            "must": [
9              {
10                "range": {
11                  "path": "items.quantity",
12                  "gt": 2
13                }
14              },
15              {
16                "exists": {
17                  "path": "items.price"
18                }
19              },
20              {
21                "text": {
22                  "path": "items.tags",
23                  "query": "school"
24                }
25              }
26            ]
27          }
28        }
29      }
30    }
31  },
32  {
33    "$limit": 2
34  },
35  {
36    "$project": {
37      "_id": 0,
38      "storeLocation": 1,
39      "items": {
40        "$filter": {
41          "input": "$items",
42          "cond": {
43            "$and": [
44              {
45                "$ifNull": [
46                  "$$this.price", "false"
47                ]
48              },
49              {
50                "$gt": [
51                  "$$this.quantity", 2
52                ]
53              },
54              {
55                "$in": [
56                  "office", "$$this.tags"
57                ]
58              }
59            ]
60          }
61        }
62      }
63    }
64  }
65)
1[
2  {
3    storeLocation: 'Austin',
4    items: [
5      {
6        name: 'laptop',
7        tags: [ 'electronics', 'school', 'office' ],
8        price: Decimal128('753.04'),
9        quantity: 3
10      },
11      {
12        name: 'pens',
13        tags: [ 'writing', 'office', 'school', 'stationary' ],
14        price: Decimal128('19.09'),
15        quantity: 4
16      },
17      {
18        name: 'notepad',
19        tags: [ 'office', 'writing', 'school' ],
20        price: Decimal128('30.23'),
21        quantity: 5
22      },
23      {
24        name: 'pens',
25        tags: [ 'writing', 'office', 'school', 'stationary' ],
26        price: Decimal128('20.05'),
27        quantity: 4
28      },
29      {
30        name: 'notepad',
31        tags: [ 'office', 'writing', 'school' ],
32        price: Decimal128('22.08'),
33        quantity: 3
34      },
35      {
36        name: 'notepad',
37        tags: [ 'office', 'writing', 'school' ],
38        price: Decimal128('21.67'),
39        quantity: 4
40      }
41    ]
42  },
43  {
44    storeLocation: 'Austin',
45    items: [
46      {
47        name: 'notepad',
48        tags: [ 'office', 'writing', 'school' ],
49        price: Decimal128('24.16'),
50        quantity: 5
51      },
52      {
53        name: 'notepad',
54        tags: [ 'office', 'writing', 'school' ],
55        price: Decimal128('28.04'),
56        quantity: 5
57      },
58      {
59        name: 'notepad',
60        tags: [ 'office', 'writing', 'school' ],
61        price: Decimal128('21.42'),
62        quantity: 5
63      },
64      {
65        name: 'laptop',
66        tags: [ 'electronics', 'school', 'office' ],
67        price: Decimal128('1540.63'),
68        quantity: 3
69      },
70      {
71        name: 'pens',
72        tags: [ 'writing', 'office', 'school', 'stationary' ],
73        price: Decimal128('29.43'),
74        quantity: 5
75      },
76      {
77        name: 'pens',
78        tags: [ 'writing', 'office', 'school', 'stationary' ],
79        price: Decimal128('28.48'),
80        quantity: 5
81      }
82    ]
83  }
84]

Obtén más información

Para obtener más información, consulte Cómo ejecutar consultas de búsqueda de MongoDB en campos de documentos integrados.

Volver

compuesto

Next

equals

En esta página