Índices para la optimización de query

Datos de muestra

Los ejemplos de esta guía utilizan el modelo Recipe, que contiene un modelo Nutrition incrustado como valor de su campo nutrition. Estas clases modelo tienen las siguientes definiciones:

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

En la clase Meta del modelo Recipe, la opción db_table = "recipes" indica al backend de Django MongoDB que asigne el modelo Recipe a una colección de MongoDB llamada recipes. Para aprender a crear una aplicación Django que use modelos para interactuar con colecciones de MongoDB, visite Introducción al tutorial de backend de MongoDB de Django.

Índice de un solo campo

Los índices de campo único almacenan información de un solo campo en una colección. Por defecto, todas las colecciones de MongoDB tienen un índice en el campo _id.

El siguiente ejemplo actualiza la clase Meta del modelo Recipe para crear un índice de campo único en el campo title, que Django MongoDB Backend crea en la colección recipes:

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

Alternativamente, puedes establecer la opción db_index en el campo title de tu modelo para crear el índice, como se muestra en el siguiente código:

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

Índice compuesto

Los índices compuestos recopilan y ordenan datos de varios campos en una colección. MongoDB agrupa los datos por el primer campo especificado en el índice y luego por cada campo subsiguiente.

El siguiente ejemplo actualiza la clase Meta del modelo Recipe para crear un índice compuesto en los campos title y cook_time, que Backend de MongoDB de Django crea en la colección recipes:

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

Multikey Index

Los índices multiclave permiten recopilar y organizar datos de campos tipo arreglo. Cuando se crea un índice en un campo tipo arreglo, MongoDB establece automáticamente dicho índice como multiclave.

El siguiente ejemplo actualiza la clase Meta del modelo Recipe para crear un índice compuesto en el campo tipo array allergens, que Django MongoDB Backend crea en la colección recipes:

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

Índice de modelos embebidos

Puede crear índices en campos que almacenan valores de modelos integrados, que MongoDB representa como documentos integrados.

El siguiente ejemplo actualiza la clase Meta del modelo Recipe para crear un índice en el campo de modelo incrustado nutrition, que Django MongoDB Backend crea en la colección recipes:

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

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

Índices de búsqueda

Los índices de búsqueda de MongoDB especifican el comportamiento de una consulta de búsqueda de MongoDB, que es una búsqueda de texto completo en sus colecciones de MongoDB.

Para crear un índice de búsqueda, asigna la opción indexes en la clase Meta de tu modelo a un objeto SearchIndex. Pasa los siguientes argumentos al constructor SearchIndex() en cualquier orden:

• fieldsLos campos que deseas indexar.

• name: (Opcional) El nombre de tu índice de búsqueda. Si no especifica este argumento, Django genera automáticamente un nombre para el índice.

A partir de Django MongoDB Backend v5.2.2, también puede pasar los siguientes argumentos a SearchIndex():

• field_mappings(Opcional) Un diccionario que asigna nombres de campos a opciones de índices. Puedes utilizar este argumento en lugar de fields para crear un índice de búsqueda complejo que especifique el comportamiento del índice para campos individuales.

• analyzer: (opcional) El analizador que se aplicará a los campos de string durante la indexación. Si no especificas este argumento, MongoDB Server utiliza lucene.standard por defecto.

• search_analyzer: (Opcional) El analizador que se aplicará al texto de la query. Si no especificas este argumento, su valor es el mismo que el de analyzer. Si omites ambos argumentos, MongoDB Server utiliza por defecto lucene.standard.

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 búsqueda vectorial.

Los índices de búsqueda vectorial de MongoDB permiten consultar datos basándose en su significado semántico, en lugar de por coincidencias de palabras clave. Es posible integrar la búsqueda vectorial con consultas de texto completo y frameworks de IA para una variedad de casos de uso.

Para crear un índice de búsqueda vectorial, asigna la opción indexes en la clase Meta de tu modelo a un objeto VectorSearchIndex. Pasa los siguientes argumentos al constructor VectorSearchIndex() en cualquier orden:

• name: (Opcional) El nombre de tu índice de búsqueda vectorial. Si no especificas este argumento, Django generará automáticamente un nombre de índice.

• fields: Los campos que desea indexar. Al menos uno debe ser un campo de vectores, representado por un arreglo de valores FloatField o IntegerField con un tamaño.

• similarities: La función de similitud que se usará. Puede usar la función de similitud "cosine", "dotProduct" o "euclidean". Especifique la función como un solo valor de string o una lista de valores que asigne funciones a campos vectoriales individuales.

El siguiente ejemplo actualiza la clase Meta del modelo Recipe para crear un índice de búsqueda vectorial llamado "vector_search_idx" en el campo vectorial ratings y en el campo numérico cook_time:

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

Índices parciales

Los índices parciales indexan únicamente los documentos de una colección que cumplen criterios de filtro específicos, lo que reduce el uso de almacenamiento y los costos de rendimiento.

Para crear un índice parcial, pasa el argumento condition al método models.Index(). Establezca el valor de la condición en un objeto Q que incluya los criterios de filtro. Al utilizar el argumento condition, también debe pasar el argumento name a models.Index().

El siguiente ejemplo actualiza la clase Meta del modelo Recipe para crear un índice parcial en el campo cuisine, indicando a Django MongoDB Backend que sólo indexe los documentos que tengan un 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

Los índices únicos te permiten evitar que los campos indexados almacenen valores duplicados. En un único campo, los índices únicos aseguran que un valor aparezca como máximo una vez para el campo especificado. En múltiples campos, los índices únicos garantizan que cualquier combinación dada de los valores clave del índice aparezca como máximo una vez.

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

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