Indexes

Considerações operacionais

Para melhorar o desempenho da query, crie índices em campos que aparecem com frequência nas queries e operações do seu aplicativo que retornam resultados ordenados. Cada índice adicionado consome espaço em disco e memória quando ativo, portanto, recomendamos que você rastreie a memória do índice e o uso do disco para o planejamento da capacidade. Além disso, quando uma operação de gravação atualiza um campo indexado, MongoDB atualiza o índice relacionado.

Como o MongoDB oferece suporte a esquemas dinâmicos, os aplicativos podem executar consulta dos campos cujos nomes não são conhecidos antecipadamente ou são arbitrários. O MongoDB 4.2 introduziu índices curinga para ajudar a suportar essas queries. Os índices curinga não são projetados para substituir o planejamento de índice baseado em volume de trabalho.

Para obter mais informações sobre como projetar seu modelo de dados e escolher os índices apropriados para seu aplicação, consulte o guia Modelagem de dados e índices no manual do MongoDB Server .

Dados de amostra

Os exemplos neste guia usam a collection sample_mflix.movies dos conjuntos de dados de amostra do Atlas. Para saber como criar um cluster MongoDB Atlas gratuito e carregar os conjuntos de dados de amostra, consulte a Introdução ao PyMongo.

Campo único e índices compostos

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 de várias teclas (índices em campos de array)

Os índices de várias chaves são índices que melhoram o desempenho de queries que especificam um campo com um índice que contém um valor de array. Você pode definir um índice de múltiplas chaves utilizando a mesma sintaxe de um único campo ou índice composto. Selecione a aba Synchronous ou Asynchronous para ver o código correspondente:

O exemplo seguinte cria um índice de múltiplas chaves no campo cast. Selecione a aba Synchronous ou Asynchronous para ver o código correspondente:

result = movies.create_index("cast")

result = await movies.create_index("cast")

O seguinte é um exemplo de uma consulta que utiliza o índice criado no exemplo de código anterior:

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

Os índices multicamadas se comportam de forma diferente de outros índices em termos de cobertura de query, computação vinculada a índice e comportamento de classificação. Para saber mais sobre índices de várias chaves, incluindo uma discussão sobre seu comportamento e limitações, consulte o guia Índices de várias chaves no manual do MongoDB Server.

Atlas Search e índices de Vector Search

Você pode gerenciar seus índices do Atlas Search e Atlas Vector Search usando o PyMongo. Os índices especificam o comportamento da busca e quais campos indexar.

O Atlas Search permite realizar pesquisas de texto completo em coleções hospedadas no MongoDB Atlas. Os índices do Atlas Search especificam o comportamento da pesquisa e quais campos indexar.

O Atlas Vector Search permite que você realize pesquisas semânticas em incorporações vetoriais armazenadas no MongoDB Atlas. Os índices de pesquisa de vetores definem os índices para as incorporações vetoriais nas quais você deseja fazer query e os valores booleanos, de data, objectId, numéricos, de string ou UUID que você deseja usar para pré-filtrar seus dados.

Você pode chamar os seguintes métodos em uma coleção para gerenciar seus índices Atlas Search e Vector Search :

• create_search_index()

• create_search_indexes()

• list_search_indexes()

• update_search_index()

• drop_search_index()

As seções a seguir fornecem exemplos de código que demonstram como usar cada um dos 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

Os índices de texto suportam queries de pesquisa de texto no conteúdo de string. Esses índices podem incluir qualquer campo cujo valor seja uma string ou uma array de elementos de string. O MongoDB suporta pesquisa de texto para vários idiomas. Você pode especificar o idioma padrão como uma opção ao criar o í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 geoespaciais

O MongoDB suporta queries de dados de coordenadas geoespaciais utilizando índices 2dsphere. Com um índice do 2dsphere, você pode executar query de inclusão, interseção e proximidade nos dados geoespaciais. Para obter mais informações sobre query de dados geoespaciais, consulte a página Queries em dados geoespaciais.

Para criar um índice do 2dsphere , você deve especificar um campo que contém somente Objetos GeoJSON. Para obter mais detalhes sobre este tipo, consulte o guia ObjetosGeoJSON no manual do MongoDB Server .

O campo location.geo no seguinte documento de amostra da coleção theaters no banco de dados sample_mflix é um objeto de ponto GeoJSON que descreve as coordenadas do 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

Índices únicos garantem que os campos indexados não armazenem valores duplicados. Por padrão, o MongoDB cria um índice único no campo _id durante a criação de uma collection. Para criar um índice único, execute as seguintes etapas:

• Especifique o campo ou a combinação de campos em que você deseja evitar a duplicação.

• Defina a opção unique como ''True''.

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

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

Índices curinga

Os índices curinga permitem queries em campos desconhecidos ou arbitrários. Esses índices podem ser benéficos se você estiver usando um esquema dinâmico.

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

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

Índices aglomerados

Os índices de cluster instruem a collection a armazenar documentos ordenados por um valor de chave. Para criar um índice clusterizado, execute as seguintes etapas ao criar sua collection:

• Especifique a opção de índice clusterizado com o campo _id como a chave.

• Defina o campo exclusivo como True.

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

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

Remover um único índice

Passe uma instância de um índice ou o nome do índice para o método drop_index() para remover um índice de uma coleção.

O exemplo a seguir remove um índice com o nome "_title_" da coleção movies. Selecione a aba Synchronous ou Asynchronous para ver o código correspondente:

movies.drop_index("_title_")

await movies.drop_index("_title_")

Remover todos os índices

A partir do MongoDB 4.2, você pode soltar todos os índices ligando para o método drop_indexes() em sua coleção. Selecione a aba Synchronous ou Asynchronous para ver o código correspondente:

collection.drop_indexes()

await collection.drop_indexes()

Para versões anteriores do MongoDB, passe "*" como parâmetro para sua chamada para drop_index() em sua collection:

collection.drop_index("*")

await collection.drop_index("*")

DuplicateKeyException

Se você executar uma operação de gravação que armazena um valor duplicado que viola um índice exclusivo, o driver gera uma DuplicateKeyException e o MongoDB lança um erro semelhante ao seguinte:

E11000 duplicate key error index

Documentação da API

Para saber mais sobre qualquer um dos métodos ou tipos discutidos neste guia, consulte a seguinte documentação da API:

• create_index()

• create_indexes()

• drop_index()

• drop_indexes()