Join us at MongoDB.local London on 7 May to unlock new possibilities for your data. Use WEB50 to save 50%.
Register now >
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 MongoDB Search embeddedDocuments tipo, embeddedDocument operador, y la opción de puntuación embedded están en vista 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 query:

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. Puedes usar la opción de puntuación embedded para configurar las opciones de puntuación. Para obtener más información, consulta Comportamiento de puntuación.

Opcional

embeddedDocument Limitaciones de 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

Cuando usted consulta documentos incrustados en arreglos utilizando el operador embeddedDocument, MongoDB Search evalúa y califica las condiciones de query del operador en diferentes etapas de la ejecución de la query. MongoDB Search:

  1. Evalúa cada documento incrustado en el arreglo 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 query a través del compuesto.

Comportamiento de la 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 ordenación

Para ordenar los documentos parent por un campo de documento incrustado, debes realizar 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 en documentos principales. No ordena los campos hijo dentro de un arreglo de documentos. Para un ejemplo, consulte Ejemplo de clasificación.

Destacando

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

Para conocer las limitaciones del operador embeddedDocument, consulta Limitaciones del operadorembeddedDocument.

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

query básica

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

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

faceta query

La siguiente query busca elementos etiquetados con school dando preferencia a los elementos llamados backpack. Solicita información de facetas 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") }
        ]
      }
    }
  }
]

Query y ordena

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

  • Excluir todos los campos salvo 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 query solo devuelve los documentos anidados que coinciden con la query. La consulta utiliza las cláusulas del operador compuesto MongoDB Search $search para encontrar los documentos coincidentes y luego el operadores de agregación en el $project para retornar sólo los documentos incrustados coincidentes. Específicamente, la consulta especifica las siguientes etapas de la pipeline:

$search

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

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

  • Busca los ítems 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

Realiza las siguientes acciones:

  • Excluya el campo _id e incluya 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 verificar si la cantidad es mayor a 2.

    • $in para verificar si office existe en el arreglo tags.

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, consulta Cómo ejecutar queries de búsqueda de MongoDB en campos de documentos incrustados.

Volver

compuesto

Next

equals

En esta página