Indexes

Consideraciones operativas

Para mejorar el rendimiento de las queries, cree índices en campos que aparezcan frecuentemente en las queries de su aplicación y en operaciones que devuelvan resultados ordenados. Cada índice que agregues consume espacio en disco y memoria cuando está activo, así que recomendamos que rastrees el uso de memoria y disco por parte del índice para la planificación de la capacidad. Además, cuando una operación de escritura actualiza un campo indexado, MongoDB actualiza el índice relacionado.

Debido a que MongoDB admite esquemas dinámicos, las aplicaciones pueden realizar consultas sobre campos cuyos nombres no se conocen de antemano o son arbitrarios. Los índices comodín facilitan estas consultas. No están diseñados para reemplazar la planificación de índices basada en la carga de trabajo.

Para obtener más información sobre cómo diseñar su modelo de datos y elegir índices apropiados para su aplicación, consulte la guía Modelado de datos e índices en el manual de MongoDB Server.

Datos de muestra

Los ejemplos de esta guía utilizan el sample_mflix.movies Colección de los conjuntos de datos de muestra de Atlas. Para aprender a crear un clúster gratuito de MongoDB Atlas y cargar los conjuntos de datos de muestra, consulte Comience a utilizar PyMongo.

Índices de campo único y compuestos

movies.create_index("title")

await movies.create_index("title")

query = { "title": "Batman" }
sort = [("title", 1)]
cursor = movies.find(query).sort(sort)

movies.create_index([("type", pymongo.ASCENDING), ("genre", pymongo.ASCENDING)])

await movies.create_index([("type", pymongo.ASCENDING), ("genre", pymongo.ASCENDING)])

query = { "type": "movie", "genre": "Drama" }
sort = [("type", pymongo.ASCENDING), ("genre", pymongo.ASCENDING)]
cursor = movies.find(query).sort(sort)

Índices multiclave (índices en campos de matriz)

Los índicesmulticlave mejoran el rendimiento de las consultas que especifican un campo con un índice que contiene un valor de matriz. Puede definir un índice multiclave utilizando la misma sintaxis que un índice de campo único o compuesto. Seleccione Synchronous Asynchronous la pestaña o para ver el código correspondiente:

El siguiente ejemplo crea un índice modular en el campo cast. Selecciona la pestaña Synchronous o Asynchronous para ver el código correspondiente:

result = movies.create_index("cast")

result = await movies.create_index("cast")

El siguiente es un ejemplo de una consulta que utiliza el índice creado en el ejemplo de código anterior:

query = { "cast": "Viola Davis" }
cursor = movies.find(query)

Los índices multiclave se comportan de forma diferente a otros índices en cuanto a la cobertura de consultas, el cálculo de los límites de índice y el comportamiento de ordenación. Para obtener más información sobre los índices multiclave, incluyendo una explicación de su comportamiento y limitaciones, consulte la guía de índices multiclave en el manual de MongoDB Server.

Índices de búsqueda vectorial y de búsqueda de MongoDB

Puedes administrar tus índices de búsqueda de MongoDB y de búsqueda vectorial de MongoDB con PyMongo. Los índices especifican el comportamiento de la búsqueda y los campos que se indexarán.

MongoDB Search permite realizar búsquedas de texto completo en colecciones alojadas en MongoDB Atlas. Los índices de MongoDB Search especifican el comportamiento de la búsqueda y los campos que se indexan.

La Búsqueda Vectorial de MongoDB permite realizar búsquedas semánticas en incrustaciones vectoriales almacenadas en MongoDB Atlas. Los índices de Búsqueda Vectorial definen los índices de las incrustaciones vectoriales que se desean consultar y los valores booleanos, de fecha, objectId, numéricos, de cadena o UUID que se utilizan para prefiltrar los datos.

Puede llamar a los siguientes métodos en una colección para administrar sus índices de búsqueda vectorial y de búsqueda de MongoDB:

• create_search_index()

• create_search_indexes()

• list_search_indexes()

• update_search_index()

• drop_search_index()

Las siguientes secciones proporcionan ejemplos de código que demuestran cómo utilizar cada uno de los métodos anteriores.

index = {
    "definition": {
        "mappings": {
            "dynamic": True
        }
    },
    "name": "<index name>",
}
collection.create_search_index(index)

index = {
    "definition": {
        "mappings": {
            "dynamic": True
        }
    },
    "name": "<index name>",
}
await collection.create_search_index(index)

from pymongo.operations import SearchIndexModel
search_index_model = SearchIndexModel(
  definition={
    "fields": [
      {
        "type": "vector",
        "numDimensions": <number of dimensions>,
        "path": "<field to index>",
        "similarity":  "<select from euclidean, cosine, dotProduct>"
      }
    ]
  },
  name="<index name>",
  type="vectorSearch",
)
collection.create_search_index(model=search_index_model)

from pymongo.operations import SearchIndexModel
search_index_model = SearchIndexModel(
  definition={
    "fields": [
      {
        "type": "vector",
        "numDimensions": <number of dimensions>,
        "path": "<field to index>",
        "similarity":  "<select from euclidean, cosine, dotProduct>"
      }
    ]
  },
  name="<index name>",
  type="vectorSearch",
)
await collection.create_search_index(model=search_index_model)

search_idx = SearchIndexModel(
    definition ={
        "mappings": {
            "dynamic": True
        }
    },
    name="my_index",
)
vector_idx = SearchIndexModel(
  definition={
    "fields": [
      {
        "type": "vector",
        "numDimensions": <number of dimensions>,
        "path": "<field to index>",
        "similarity": "<select from euclidean, cosine, dotProduct>"
      }
    ]
  },
  name="my_vector_index",
  type="vectorSearch",
)
indexes = [search_idx, vector_idx]
collection.create_search_indexes(models=indexes)

search_idx = SearchIndexModel(
    definition ={
        "mappings": {
            "dynamic": True
        }
    },
    name="my_index",
)
vector_idx = SearchIndexModel(
  definition={
    "fields": [
      {
        "type": "vector",
        "numDimensions": <number of dimensions>,
        "path": "<field to index>",
        "similarity": "<select from euclidean, cosine, dotProduct>"
      }
    ]
  },
  name="my_vector_index",
  type="vectorSearch",
)
indexes = [search_idx, vector_idx]
await collection.create_search_indexes(models=indexes)

results = list(collection.list_search_indexes())
for index in results:
    print(index)

results = await (await collection.list_search_indexes()).to_list()
async for index in results:
    print(index)

new_index_definition = {
    "mappings": {
        "dynamic": False
    }
}
collection.update_search_index("my_index", new_index)

new_index_definition = {
    "fields": [
        {
            "type": "vector",
            "numDimensions": 1536,
            "path": "<field to index>",
            "similarity": "euclidean"
        },
    ]
}
collection.update_search_index("my_vector_index", new_index_definition)

new_index_definition = {
    "fields": [
        {
            "type": "vector",
            "numDimensions": 1536,
            "path": "<field to index>",
            "similarity": "euclidean"
        },
    ]
}
await collection.update_search_index("my_vector_index", new_index_definition)

collection.drop_search_index("my_index")

await collection.drop_search_index("my_index")

Text Indexes

Los índices de texto permiten realizar búsquedas de texto en cadenas. Estos índices pueden incluir cualquier campo cuyo valor sea una cadena o un array de elementos de cadena. MongoDB admite la búsqueda de texto en varios idiomas. Puede especificar el idioma predeterminado al crear el índice.

movies.create_index(
    [( "plot", "text" )]
)

await movies.create_index(
    [( "plot", "text" )]
)

query = { "$text": { "$search": "a time-traveling DeLorean" } }
cursor = movies.find(query)

from pymongo.collation import Collation
result = myColl.create_index(
    [("title", "text"), ("genre", "text")],
    default_language="english",
    weights={ "title": 10, "genre": 3 },
    collation=Collation(locale='fr_CA')
)

from pymongo.collation import Collation
result = await myColl.create_index(
    [("title", "text"), ("genre", "text")],
    default_language="english",
    weights={ "title": 10, "genre": 3 },
    collation=Collation(locale='fr_CA')
)

Índices geoespaciales

MongoDB admite consultas de datos de coordenadas geoespaciales mediante 2índices dsphere. Con un 2dsphere índice, puede consultar los datos geoespaciales por inclusión, intersección y proximidad. Para obtener más información sobre cómo consultar datos geoespaciales, consulte Consultas geoespaciales.

Para crear un 2dsphere índice, debe especificar un campo que contenga únicamente objetos GeoJSON. Para más información sobre este tipo, consulte la guía de objetos GeoJSON en el manual de MongoDB Server.

El campo location.geo en el siguiente documento de muestra de la colección theaters en la base de datos sample_mflix es un objeto Punto GeoJSON que describe las coordenadas del teatro:

{
   "_id" : ObjectId("59a47286cfa9a3a73e51e75c"),
   "theaterId" : 104,
   "location" : {
      "address" : {
         "street1" : "5000 W 147th St",
         "city" : "Hawthorne",
         "state" : "CA",
         "zipcode" : "90250"
      },
      "geo" : {
         "type" : "Point",
         "coordinates" : [
            -118.36559,
            33.897167
         ]
      }
   }
}

theaters.create_index(
    [( "location.geo", "2dsphere" )]
)

await theaters.create_index(
    [( "location.geo", "2dsphere" )]
)

Unique Indexes

Los índices únicos garantizan que los campos indexados no almacenen valores duplicados. De forma predeterminada, MongoDB crea un índice único en el campo _id durante la creación de una colección. Para crear un índice único, siga estos pasos:

• Especifique el campo o la combinación de campos en los que desea evitar la duplicación.

• Establezca la opción unique en "Verdadero".

theaters.create_index("theaterId", unique=True)

await theaters.create_index("theaterId", unique=True)

Índices comodín

Los índices comodín permiten realizar consultas sobre campos desconocidos o arbitrarios. Estos índices pueden ser beneficiosos si se utiliza un esquema dinámico.

movies.create_index({ "location.$**": pymongo.ASCENDING })

await movies.create_index({ "location.$**": pymongo.ASCENDING })

Índices agrupados

Los índices agrupados indican a una colección que almacene documentos ordenados por un valor de clave. Para crear un índice agrupado, siga estos pasos al crear su colección:

• Especifique la opción de índice agrupado con el campo _id como clave.

• Establezca el campo único en True.

sample_mflix.create_collection("movies", clusteredIndex={
    "key": { "_id": 1 }, 
    "unique": True
})

await sample_mflix.create_collection("movies", clusteredIndex={
    "key": { "_id": 1 }, 
    "unique": True
})

Eliminar un solo índice

Pase una instancia de un índice o el nombre del índice al método drop_index() para eliminar un índice de una colección.

El siguiente ejemplo elimina un índice llamado "_title_" de la colección movies. Seleccione la pestaña Synchronous o Asynchronous para ver el código correspondiente:

movies.drop_index("_title_")

await movies.drop_index("_title_")

Eliminar todos los índices

A partir de MongoDB 4.2, puede eliminar todos los índices llamando al método drop_indexes() de su colección. Seleccione la pestaña Synchronous o Asynchronous para ver el código correspondiente:

collection.drop_indexes()

await collection.drop_indexes()

Para versiones anteriores de MongoDB, pase "*" como parámetro a su llamada a drop_index() en su colección:

collection.drop_index("*")

await collection.drop_index("*")

Excepción de clave duplicada

Si realiza una operación de escritura que almacena un valor duplicado que viola un índice único, el controlador genera un DuplicateKeyException y MongoDB arroja un error similar al siguiente:

E11000 duplicate key error index

Documentación de la API

Para aprender más sobre cualquiera de los métodos o tipos analizados en esta guía, consulta la siguiente documentación de API:

• create_index()

• create_indexes()

• drop_index()

• drop_indexes()