Índices comodín

Crear un índice comodín en un campo

Para indexar el valor de un campo específico:

db.collection.createIndex( { "fieldA.$**" : 1 } )

Con este índice comodín, MongoDB indexa todos los valores de fieldA. Si el campo es un documento anidado o un arreglo, el índice comodín recorre el documento/arreglo y almacena el valor de todos los campos en el documento/arreglo.

Por ejemplo, los documentos de la colección product_catalog pueden contener un campo product_attributes. El product_attributes campo puede contener campos anidados arbitrarios, incluidos documentos incrustados y arreglos:

{
  "product_name" : "Spy Coat",
  "product_attributes" : {
    "material" : [ "Tweed", "Wool", "Leather" ]
    "size" : {
      "length" : 72,
      "units" : "inches"
    }
  }
}
{
  "product_name" : "Spy Pen",
  "product_attributes" : {
     "colors" : [ "Blue", "Black" ],
     "secret_feature" : {
       "name" : "laser",
       "power" : "1000",
       "units" : "watts",
     }
  }
}

La siguiente operación crea un índice comodín en el campo product_attributes:

db.products_catalog.createIndex( { "product_attributes.$**" : 1 } )

El índice comodín puede admitir consultas arbitrarias de un solo campo en product_attributes o en sus campos incrustados:

db.products_catalog.find( { "product_attributes.size.length" : { $gt : 60 } } )
db.products_catalog.find( { "product_attributes.material" : "Leather" } )
db.products_catalog.find( { "product_attributes.secret_feature.name" : "laser" } )

Para un ejemplo, consulta Crear un índice comodín en una única ruta de campo.

Crea un índice comodín en todos los campos

Para indexar el valor de todos los campos de un documento (excluyendo _id), especifique "$**" como clave de índice:

db.collection.createIndex( { "$**" : 1 } )

Con este índice comodín, MongoDB indexa todos los campos para cada documento en la colección. Si un campo determinado es un documento anidado o un arreglo, el índice comodín recurre al documento/arreglo y almacena el valor de todos los campos en el documento/arreglo.

Para un ejemplo, consulte Crear un índice comodín en todas las rutas de campos.

Crear un índice comodín en varios campos específicos

Para indexar los valores de varios campos específicos en un documento:

db.collection.createIndex(
  { "$**" : 1 },
  { "wildcardProjection" :
    { "fieldA" : 1, "fieldB.fieldC" : 1 }
  }
)

Con este índice comodín, MongoDB indexa todos los valores para los campos especificados en cada documento de la colección. Si un campo específico es un documento anidado o un arreglo, el índice comodín recurre al documento/arreglo y almacena el valor de todos los campos en el documento/arreglo.

Para ver un ejemplo, consulte Incluir campos específicos en la cobertura del índice comodín.

Crea un índice comodín que excluya múltiples campos específicos

Para indexar los campos de todos los campos de un documento excepto rutas de campo específicas:

db.collection.createIndex(
  { "$**" : 1 },
  { "wildcardProjection" :
    { "fieldA" : 0, "fieldB.fieldC" : 0 }
  }
)

Con este índice comodín, MongoDB indexa todos los campos de cada documento en la colección excluyendo las rutas de campo especificadas. Si un campo dado es un documento anidado o un arreglo, el índice comodín recorre el documento/arreglo y almacena los valores de todos los campos en el documento/arreglo.

Para ver un ejemplo, consulte Omitir campos específicos de la cobertura del índice comodín.

Objetos anidados

Cuando un índice comodín encuentra un objeto anidado, desciende al objeto e indexa su contenido. Por ejemplo:

{
  "parentField" : {
    "nestedField" : "nestedValue",
    "nestedArray" : ["nestedElement"]
    "nestedObject" : {
      "deeplyNestedField" : "deeplyNestedValue"
    }
  }
}

Un índice comodín que incluye parentField desciende en el objeto para recorrer e indexar su contenido:

• Para cada campo que sea en sí mismo un objeto (es decir, un documento incrustado), se debe descender al objeto para indexar su contenido.

• Para cada campo que sea un arreglo, recorra el arreglo e indexe su contenido.

• Para todos los demás campos, registra el valor primitivo (no objeto/arreglo) en el índice.

El índice comodín sigue recorriendo cualquier objeto o arreglo anidado adicional hasta que llega a un valor primitivo (es decir, un campo que no es un objeto o arreglo). Luego indexa este valor primitivo, junto con la ruta completa a ese campo.

Dado el documento de muestra, el índice comodín agrega los siguientes registros al índice:

• "parentField.nestedField" : "nestedValue"

• "parentField.nestedObject.deeplyNestedField" : "deeplyNestedValue"

• "parentField.nestedArray" : "nestedElement"

Para obtener más información sobre el comportamiento del índice comodín con matrices anidadas, consulte Matrices anidadas.

Arreglos anidados

Cuando un índice comodín encuentra una matriz anidada, intenta recorrerla para indexar sus elementos. Si la matriz es a su vez un elemento de una matriz principal (es decir, una matriz incrustada), el índice comodín registra la matriz completa como valor en lugar de recorrer su contenido. Por ejemplo:

{
  "parentArray" : [
    "arrayElementOne",
    [ "embeddedArrayElement" ],
    "nestedObject" : {
      "nestedArray" : [
        "nestedArrayElementOne",
        "nestedArrayElementTwo"
      ]
    }
  ]
}

Un índice comodín que incluye parentArray desciende en el arreglo para recorrer e indexar su contenido:

• Para cada elemento que es un arreglo (es decir, un arreglo incrustado), indexa el arreglo completo como un valor.

• Para cada elemento que sea un objeto, descienda en el objeto para recorrer e indexar su contenido.

• Para todos los demás campos, registra el valor primitivo (no objeto/arreglo) en el índice.

El índice comodín sigue recorriendo cualquier objeto o arreglo anidado adicional hasta que llega a un valor primitivo (es decir, un campo que no es un objeto o arreglo). Luego indexa este valor primitivo, junto con la ruta completa a ese campo.

Dado el documento de muestra, el índice comodín agrega los siguientes registros al índice:

• "parentArray" : "arrayElementOne"

• "parentArray" : ["embeddedArrayElement"]

• "parentArray.nestedObject.nestedArray" : "nestedArrayElementOne"

• "parentArray.nestedObject.nestedArray" : "nestedArrayElementTwo"

Tenga en cuenta que los registros de parentField.nestedArray no incluyen la posición en el arreglo de cada elemento. Los índices comodín ignoran las posiciones de los elementos de un arreglo al registrar el elemento en el índice. Los índices comodín todavía pueden admitir consultas que incluyan índices de arreglo explícitos. Consulta Consultas con índices de arreglos explícitos para obtener más información.

Index Display

A partir de MongoDB 6.3, 6.0.5 y 5.0.16, el campo wildcardProjection almacena la proyección del índice en su forma presentada. Las versiones anteriores del servidor podrían haber almacenado la proyección en una forma normalizada.

El servidor utiliza el índice de la misma manera, pero podría notar una diferencia en la salida de los comandos listIndexes y db.collection.getIndexes().

Consultas cubiertas

Los índices comodín pueden admitir una consulta cubierta solo si se cumplen todas las siguientes condiciones:

• El planificador de consultas selecciona el índice comodín para satisfacer el predicado de la consulta.

• El predicado de la query especifica exactamente un campo cubierto por el índice comodín.

• La proyección excluye explícitamente _id e incluye solo el campo de consulta.

• El campo de query especificado nunca es un arreglo.

Observa el siguiente índice comodín de la colección employees:

db.employees.createIndex( { "$**" : 1 } )

La siguiente operación realiza una query para un único campo lastName y proyecta todos los demás campos del documento resultante:

db.employees.find(
  { "lastName" : "Doe" },
  { "_id" : 0, "lastName" : 1 }
)

Suponiendo que el lastName especificado nunca es una matriz, MongoDB puede usar el índice comodín $** para soportar una consulta cubierta.

Predicados de consulta de múltiples campos

Los índices comodín admiten como máximo un campo de predicado de consulta. Es decir:

• MongoDB no puede utilizar un índice no de comodín para satisfacer una parte de un predicado de query y un índice comodín para satisfacer otra.

• MongoDB no puede utilizar un índice comodín para satisfacer una parte de un predicado de consulta y otro índice comodín para satisfacer otra.

• Incluso si un único índice comodín pudiera soportar múltiples campos de query, MongoDB solo puede utilizar el índice comodín para soportar uno de los campos de query. Todos los campos restantes se resuelven sin un índice.

Sin embargo, MongoDB puede utilizar el mismo índice comodín para satisfacer cada argumento independiente de los operadores $or de consulta $or o de agregación.

Las query con ordenación

MongoDB puede usar un índice comodín para satisfacer el sort() solo si se cumplen todas las siguientes condiciones:

• El planificador de consultas selecciona el índice comodín para satisfacer el predicado de la consulta.

• El sort() especifica solo el campo del predicado de la query.

• El campo especificado nunca es un arreglo.

Si no se cumplen las condiciones anteriores, MongoDB no puede usar el índice comodín para la ordenación. MongoDB no admite operaciones que requieran un índice diferente al del predicado de la consulta. Para obtener más información,sort() consulte Intersección de índices y ordenación.

Observa el siguiente índice comodín de la colección products:

db.products.createIndex( { "product_attributes.$**" : 1 } )

La siguiente operación consulta un solo campo product_attributes.price y ordena según ese mismo campo:

db.products.find(
  { "product_attributes.price" : { $gt : 10.00 } },
).sort(
  { "product_attributes.price" : 1 }
)

Suponiendo que el price especificado nunca sea un arreglo, MongoDB puede usar el índice comodín product_attributes.$** para satisfacer tanto el find() como el sort().

Patrones de query no compatibles

Los índices comodín no pueden admitir los siguientes patrones de consulta:

• Consultas que comprueban si un campo no existe

• Consultas que verifican si un campo es igual o no a un documento o a un arreglo

• Consultas que comprueban si un campo es igual a null

Para obtener más detalles,consulte Patrones de consulta y agregación no admitidos.

Consultas con índices de arreglo explícitos

Los índices comodín de MongoDB no registran la posición de un arreglo de ningún elemento dado en un arreglo durante la indexación. Sin embargo, MongoDB aún puede seleccionar el índice comodín para responder una query que incluya una ruta de campo con uno o más índices explícitos de arreglo (por ejemplo parentArray.0.nestedArray.0). Debido a la creciente complejidad de definir los límites del índice para cada arreglo anidado consecutivo, MongoDB no considera el índice comodín para responder una ruta de campo dada en la query si esa ruta contiene más de 8 índices explícitos de arreglo. MongoDB aún puede considerar el índice de comodín para responder otras rutas de campo en la query.

Por ejemplo:

{
  "parentObject" : {
    "nestedArray" : [
       "elementOne",
       {
         "deeplyNestedArray" : [ "elementTwo" ]
       }
     ]
  }
}

MongoDB puede seleccionar un índice comodín que incluya parentObject para satisfacer las siguientes consultas:

• "parentObject.nestedArray.0" : "elementOne"

• "parentObject.nestedArray.1.deeplyNestedArray.0" : "elementTwo"

Si una determinada ruta de campo en el predicado de query especifica más de 8 índices de arreglo explícitos, MongoDB no considera el índice comodín para responder a esa ruta de campo. MongoDB en su lugar selecciona otro índice elegible para responder a la consulta, o realiza un escaneo de colección.

Tenga en cuenta que los índices comodín no tienen límites en la profundidad con la que recorren un documento al indexarlo; esta limitación solo se aplica a consultas que especifican explícitamente índices de matriz exactos. Al ejecutar las mismas consultas sin los índices de matriz explícitos, MongoDB puede seleccionar el índice comodín para responder a la consulta:

• "parentObject.nestedArray" : "elementOne"

• "parentObject.nestedArray.deeplyNestedArray" : "elementTwo"