Crie índices

Dados de amostra

Os exemplos neste guia usam o modelo Recipe, que contém um modelo Nutrition incorporado como valor de seu campo nutrition. Essas classes de modelo têm as seguintes definições:

from django.db import models
from django.db.models import Q, F
from django_mongodb_backend.models import EmbeddedModel
from django_mongodb_backend.fields import EmbeddedModelField, ArrayField
from django_mongodb_backend.indexes import SearchIndex, VectorSearchIndex
class Nutrition(EmbeddedModel):
    calories = models.IntegerField(default=0)
    carb_grams = models.IntegerField(default=0)
    protein_grams = models.IntegerField(default=0)
class Recipe(models.Model):
    title = models.CharField(max_length=200)
    cuisine = models.CharField(max_length=200)
    cook_time = models.IntegerField(default=0)
    allergens = ArrayField(models.CharField(max_length=100), null=True, blank=True)
    ratings = ArrayField(models.IntegerField(default=0), size=10)
    nutrition = EmbeddedModelField(Nutrition, null=True, blank=True)
    class Meta:
        db_table = "recipes"
    def __str__(self):
        return self.title

Na classe Meta do modelo Recipe, a opção db_table = "recipes" instrui o backend do Django MongoDB a mapear o modelo Recipe para uma collection do MongoDB chamada recipes. Para saber como criar um aplicação Django que use modelos para interagir com coleções do MongoDB, acesse o tutorial de Introdução.

Índice de campo único

Os índices de campo único armazenam informações de um único campo em uma coleção. Por padrão, todas as collections do MongoDB têm um índice no campo _id.

O exemplo a seguir atualiza a classe Meta do modelo Recipe para criar um único índice de campo no campo title , que o backend do Django MongoDB cria na coleção recipes:

class Meta:
    db_table = "recipes"
    indexes = [
        models.Index(fields=["title"], name="title_idx"),
    ]

Como alternativa, você pode definir a opção db_index no campo title do seu modelo para criar o índice, conforme mostrado no código a seguir:

class Recipe(models.Model):
    title = models.CharField(max_length=200, db_index=True)

Índice composto

Os índices compostos coletam e classificam dados de vários campos em uma collection. O MongoDB agrupa dados pelo primeiro campo especificado no índice e, em seguida, por cada campo subsequente.

O exemplo a seguir atualiza a classe Meta do modelo Recipe para criar um índice composto nos campos title e cook_time, que o Django MongoDB Backend cria na coleção recipes:

class Meta:
    db_table = "recipes"
    indexes = [
        models.Index(fields=["title", "cook_time"]),
    ]

Multikey Index

Índices de múltiplas chave coletam e classificam dados de campos de array. Quando você cria um índice em um campo de array , o MongoDB define automaticamente esse índice como um índice de várias chaves.

O exemplo a seguir atualiza a classe Meta do modelo Recipe para criar um índice composto no campo de array allergens, que o backend do Django MongoDB cria na coleção recipes:

class Meta:
    db_table = "recipes"
    indexes = [
        models.Index(fields=["allergens"], name="allergy_idx"),
    ]

Índice de documentos incorporado

Você pode criar índices em campos que armazenam valores de modelo incorporados, que o MongoDB representa como documentos incorporados.

O exemplo a seguir atualiza a classe Meta do modelo Recipe para criar um índice no campo do modelo incorporado nutrition, que o backend do Django MongoDB cria na coleção recipes:

class Meta:
    db_table = "recipes"
    indexes = [
        models.Index(fields=["nutrition"]),
    ]

Índices de pesquisa

Os índices do MongoDB Search especificam o comportamento de uma query do MongoDB Search, que é uma pesquisa de texto completo em suas coleções do MongoDB .

Para criar um índice de pesquisa, atribua a opção indexes na classe Meta do seu modelo a um objeto SearchIndex. Passe os seguintes argumentos para o construtor SearchIndex() em qualquer ordem:

• fields: Os campos que você deseja indexar.

• name: (Opcional) O nome do seu índice de pesquisa. Se você não especificar este argumento, o Django gerará automaticamente um nome de índice.

A partir do Django MongoDB Backend v5.2.2, você também pode passar os seguintes argumentos para SearchIndex():

• field_mappings: (Opcional) Um dicionário que mapeia os nomes dos campo para as opções de índice. Você pode utilizar este argumento em vez de fields para criar um índice de pesquisa complexo que especifica o comportamento do índice para campos individuais.

• analyzer: (Opcional) O analisador a ser aplicado aos campos da string durante a indexação. Se você não especificar este argumento, o padrão do MongoDB Server lucene.standard será.

• search_analyzer: (Opcional) O analisador a aplicar ao texto da query. Se você não especificar este argumento, seu valor será o mesmo que seu analyzer valor de. Se você omitir ambos os argumentos, o lucene.standard padrão do MongoDB Server será.

class Meta:
    db_table = "recipes"
    indexes = [
        SearchIndex(
            fields=["title"],
            name="title_search_idx",
        )
    ]

class Meta:
    db_table = "recipes"
    indexes = [
        SearchIndex(
            name="cuisine_search_idx",
            field_mappings={
                "cuisine": {
                    "type": "token"
                }
            },
            analyzer="lucene.simple"
        )
    ]

Índices de Vector Search

Os índices do MongoDB Vector Search permitem fazer query de dados com base em seu significado semântica, em vez de por correspondências de palavras-chave. Você pode integrar a pesquisa vetorial com queries de pesquisa de texto completo e frameworks de IA para dar suporte a uma variedade de casos de uso.

Para criar um índice de pesquisa vetorial, atribua a opção indexes na classe Meta do seu modelo a um objeto VectorSearchIndex. Passe os seguintes argumentos para o construtor VectorSearchIndex() em qualquer ordem:

• name: (Opcional) O nome do seu índice do Vector Search . Se você não especificar este argumento, o Django gerará automaticamente um nome de índice.

• fields: Os campos que você deseja indexar. Pelo menos um deve ser um campo de vetor, representado por uma array de FloatField ou IntegerField valores com um tamanho.

• similarities: a função de similaridade a ser usada. Você pode usar a função de similaridade "cosine", "dotProduct" ou "euclidean". Especifique a função como um único valor de string ou uma lista de valores que atribui funções a campos de vetor individuais.

O exemplo seguinte atualiza a classe Meta do modelo Recipe para criar um índice de pesquisa vetorial denominado "vector_search_idx" no campo vetorial ratings e no campo numérico cook_time :

class Meta:
    db_table = "recipes"
    indexes = [
        VectorSearchIndex(
            name=["vector_search_idx"],
            fields=["ratings", "cook_time"],
            similarities=["cosine", "euclidean"],
        )
    ]

Índices Parciais

Os índices parciais indexam apenas os documentos em uma collection que atendem aos critérios de filtro especificados, o que reduz o uso de armazenamento e os custos de desempenho.

Para criar um índice parcial, passe o argumento condition para o método models.Index(). Defina o valor da condição como um objeto Q que inclua os critérios de filtro. Ao usar o argumento condition, você também deve passar o argumento name para models.Index().

O exemplo a seguir atualiza a classe Meta do modelo Recipe para criar um índice parcial no campo cuisine, instruindo o Backend do Django MongoDB a indexar apenas documentos que tenham um valor cook_time menor que 30:

class Meta:
    db_table = "recipes"
    indexes = [
        models.Index(fields=["cuisine"],
                     condition=Q(cook_time__lt=30),
                     name="fast_cuisine_idx"),
    ]

Unique Indexes

Índices únicos permitem evitar que campos indexados armazenem valores duplicados. Em um único campo, índices únicos garantem que um valor apareça , no máximo , uma vez no campo especificado . Em vários campos, índices únicos garantem que qualquer combinação dos valores de chave de índice apareça no máximo uma vez.

cuisine = models.CharField(max_length=200, unique=True)

class Meta:
    db_table = "recipes"
    constraints = [
        models.UniqueConstraint(fields=["title", "cuisine"],
                                name="unique_regional_meal"),
    ]