db.colección.createIndexes() (método mongosh)

Uso de la intercalación y del índice

Si has especificado una intercalación a nivel de colección, entonces:

• Si no especificas una intercalación al crear el índice, MongoDB crea el índice con la intercalación por defecto de la colección.

• Si especificas una intercalación al crear el índice, MongoDB crea el índice con la intercalación especificada.

Puedes crear múltiples índices en las mismas claves con diferentes intercalaciones. Para crear índices con el mismo patrón de clave pero diferentes intercalaciones, debes proporcionar nombres de índice únicos.

Para utilizar un índice para las comparaciones de cadenas, una operación también debe especificar la misma intercalación. Es decir, un índice con una intercalación no puede soportar una operación que realice comparaciones de strings en los campos indexados si la operación especifica una intercalación diferente.

Una colección restaurants tiene los siguientes documentos:

db.restaurants.insertMany( [
   { _id: 1, category: "café", status: "Open" },
   { _id: 2, category: "cafe", status: "open" },
   { _id: 3, category: "cafE", status: "open" }
] )

La colección restaurants tiene un índice en un campo de string category con la intercalación de la localización "fr".

db.restaurants.createIndex( { category: 1 }, { collation: { locale: "fr" } } )

La siguiente query, que especifica la misma intercalación que el índice, puede utilizar el índice:

db.restaurants.find( { category: "cafe" } ).collation( { locale: "fr" } )

Sin embargo, la siguiente operación de query, que por defecto utiliza el intercalador binario "simple", no puede usarse el índice:

db.restaurants.find( { category: "cafe" } )

Para un índice compuesto donde las claves prefijo del índice no son cadenas, arreglos ni documentos incrustados, una operación que especifique una intercalación diferente puede seguir utilizando el índice para soportar comparaciones en las claves prefijo del índice.

Por ejemplo, la colección restaurants tiene un índice compuesto en los campos numéricos score y price y el campo de string category; el índice se crea con la localización de intercalación "fr" para comparaciones de strings:

db.restaurants.createIndex(
   { score: 1, price: 1, category: 1 },
   { collation: { locale: "fr" } } )

Las siguientes operaciones, que utilizan la intercalación binaria "simple" para las comparaciones de strings, pueden usar el índice:

db.restaurants.find( { score: 5 } ).sort( { price: 1 } )
db.restaurants.find( { score: 5, price: { $gt: Decimal128( "10" ) } } ).sort( { price: 1 } )

La siguiente operación, que utiliza la intercalación binaria "simple" para las comparaciones de string en el campo category indexado, puede usar el índice para cumplir solo con la parte score: 5 de la query:

db.restaurants.find( { score: 5, category: "cafe" } )

Para confirmar si una consulta ha utilizado un índice, ejecuta la consulta con la opción explain().

Opciones sin intercalación y no ocultas

Con la excepción de la opción de intercalación, si se crea un índice con un conjunto de opciones de índice y luego intenta volver a crear el mismo índice, pero con opciones de índice diferentes, MongoDB no cambiará las opciones ni volverá a crear el índice.

La opción oculta se puede cambiar sin eliminar ni volver a crear el índice. Consulta Opción oculta.

Para cambiar las otras opciones del índice, se debe descartar el índice existente con db.collection.dropIndex() antes de ejecutar db.collection.createIndexes() con las nuevas opciones.

Opción de intercalación

Puedes crear múltiples índices en las mismas claves con diferentes intercalaciones. Para crear índices con el mismo patrón de clave pero diferentes intercalaciones, debes proporcionar nombres de índice únicos.

Opción oculta

Para ocultar o mostrar índices existentes, puede utilizar los siguientes mongosh métodos:

• db.collection.hideIndex()

• db.collection.unhideIndex()

Por ejemplo,

• Para cambiar la opción hidden de un índice a true, utiliza el método db.collection.hideIndex():

  db.restaurants.hideIndex( { borough: 1, ratings: 1 } );

• Para cambiar la opción hidden de un índice a false, utiliza el método db.collection.unhideIndex():

  db.restaurants.unhideIndex( { borough: 1, city: 1 } );

Crear un índice comodín en una ruta de un solo campo

db.products_catalog.insertMany( [
  {
    _id : ObjectId("5c1d358bf383fbee028aea0b"),
    product_name: "Jeans",
    product_attributes: {
      price: {
        cost: 29.99,
        currency: "USD"
      }
    }
  },
  {
    _id: ObjectId("5c1d358bf383fbee028aea0c"),
    product_name: "Sweater",
    product_attributes: {
      washable: true,
      size: [ "small", "medium", "large" ]
    }
  }
] )

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

use inventory
db.products_catalog.createIndexes(
  [ { "product_attributes.$**" : 1 } ]
)

Con este índice comodín, MongoDB indexa todos los valores escalares de product_attributes. Si el campo es un documento o arreglo anidado, el índice comodín recorre el documento/arreglo e indexa todos los campos escalares del documento/arreglo.

El índice comodín puede brindar soporte a queries arbitrarias de un solo campo en product_attributes o en uno de sus campos anidados:

db.products_catalog.find( { "product_attributes.washable" : true } )
db.products_catalog.find( { "product_attributes.maxSize" : { $gt : 20 } } )
db.products_catalog.find( { "product_attributes.colors" : { $eq: "blue" } } )

Crear un índice comodín en todas las rutas de campos

db.products_catalog.insertMany( [
  {
    _id : ObjectId("5c1d358bf383fbee028aea0b"),
    product_name: "Jeans",
    product_attributes: {
      price: {
        cost: 29.99,
        currency: "USD"
      }
    }
  },
  {
    _id: ObjectId("5c1d358bf383fbee028aea0c"),
    product_name: "Sweater",
    product_attributes: {
      washable: true,
      size: [ "small", "medium", "large" ]
    }
  }
] )

La siguiente operación crea un índice comodín en todos los campos escalares (excluyendo el campo _id):

use inventory
db.products_catalog.createIndexes( [ { "$**" : 1 } ] )

Con este índice comodín, MongoDB indexa todos los campos escalares de cada documento de la colección. Si un campo dado es un documento o arreglo anidado, el índice comodín recorre el documento/arreglo e indexa todos los campos escalares del documento/arreglo.

El índice creado puede soportar queries sobre cualquier campo arbitrario dentro de los documentos de la colección:

db.products_catalog.find( { "product_price" : { $lt : 25 } } )
db.products_catalog.find( { "product_attributes.colors" : { $eq: "blue" } } )

Crear un índice comodín en múltiples rutas de campos específicos

db.products_catalog.insertMany( [
  {
    _id : ObjectId("5c1d358bf383fbee028aea0b"),
    product_name: "Jeans",
    product_attributes: {
      price: {
        cost: 29.99,
        currency: "USD"
      }
    }
  },
  {
    _id: ObjectId("5c1d358bf383fbee028aea0c"),
    product_name: "Sweater",
    product_attributes: {
      washable: true,
      size: [ "small", "medium", "large" ]
    }
  }
] )

La siguiente operación crea un índice comodín y utiliza la opción wildcardProjection para incluir únicamente los valores escalares de los campos product_attributes.colors y product_attributes.material en el índice.

use inventory
db.products_catalog.createIndexes(
  [ { "$**" : 1 } ],
  {
    "wildcardProjection" : {
      "product_attributes.colors" : 1,
      "product_attributes.material" : 1
    }
  }
)

El patrón "$**" incluye todos los campos del documento. Utilice el campo wildcardProjection para limitar el índice a los campos especificados.

Para obtener la documentación completa wildcardProjection sobre, consulte Opciones para wildcard índices.

Si un campo es un documento o un arreglo anidado, el índice comodín recorre el documento/arreglo e indexa todos los campos escalares del documento/arreglo.

El índice comodín admite consultas en cualquier campo escalar incluido en el wildcardProjection:

db.products_catalog.find( { "product_attributes.colors" : { $eq: "Blue" } } )
db.products_catalog.find( { "product_attributes.material" : "Cotton" } )

Omitir campos específicos de la cobertura de índices comodín

db.products_catalog.insertMany( [
  {
    _id : ObjectId("5c1d358bf383fbee028aea0b"),
    product_name: "Jeans",
    product_attributes: {
      price: {
        cost: 29.99,
        currency: "USD"
      }
    }
  },
  {
    _id: ObjectId("5c1d358bf383fbee028aea0c"),
    product_name: "Sweater",
    product_attributes: {
      washable: true,
      size: [ "small", "medium", "large" ]
    }
  }
] )

Este ejemplo utiliza un índice comodín y un documento wildcardProjection para indexar los campos escalares de cada documento de la colección. El índice comodín excluye los campos product_attributes.colors y product_attributes.material:

use inventory
db.products_catalog.createIndexes(
  [ { "$**" : 1 } ],
  {
    "wildcardProjection" : {
      "product_attributes.colors" : 0,
      "product_attributes.material" : 0
    }
  }
)

El patrón comodín "$**" incluye todos los campos del documento. Sin embargo, el campo wildcardProjection excluye los campos especificados del índice.

Para obtener la documentación completa wildcardProjection sobre, consulte Opciones para wildcard índices.

Si un campo es un documento o un arreglo anidado, el índice comodín recorre el documento/arreglo e indexa todos los campos escalares del documento/arreglo.

El índice puede admitir consultas en cualquier campo escalar excepto los campos excluidos wildcardProjection por:

db.products_catalog.find( { "product_attributes.maxSize" : { $gt: 25 } } )
db.products_catalog.find( { "product_attributes.washable" : true } )