Cree índices

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 Tutorial de introducción.

Índice de un solo campo

Los índices de campo único almacenan información de un solo campo en una colección. De forma predeterminada, 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, puede configurar la opción db_index en el campo title de su 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 de una colección. MongoDB agrupa los datos según el primer campo especificado en el índice y, a continuación, según 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 Django MongoDB Backend crea en la colección recipes:

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

Multikey Index

Los índices multiclave recopilan y ordenan datos de campos de matriz. Al crear un índice en un campo de matriz, MongoDB lo define automáticamente como multiclave.

El siguiente ejemplo actualiza la clase Meta del modelo Recipe para crear un índice compuesto en el campo de matriz 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 documentos incrustados

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 del modelo incrustado nutrition, que Django MongoDB Backend crea en la colección recipes:

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

Í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, asigne la opción indexes de la clase Meta de su modelo a un objeto SearchIndex. Pase los siguientes argumentos al constructor SearchIndex() en cualquier orden:

• fields:Los campos que desea 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 puedes pasar los siguientes argumentos a SearchIndex():

• field_mappings: (Opcional) Un diccionario que asigna nombres de campo a opciones de índice. Puede usar 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 cadena durante la indexación. Si no se especifica este argumento, MongoDB Server toma como valor lucene.standard predeterminado.

• search_analyzer: (Opcional) El analizador que se aplicará al texto de la consulta. Si no especifica este argumento, su valor será el mismo que el analyzer de. Si omite ambos argumentos, MongoDB Server toma lucene.standard como valor predeterminado.

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, asigne la opción indexes de la clase Meta de su modelo a un objeto VectorSearchIndex. Pase los siguientes argumentos al constructor VectorSearchIndex() en cualquier orden:

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

• fieldsLos campos que desea indexar. Al menos uno debe ser un campo vectorial, representado por una matriz de FloatField IntegerField valores o con un tamaño.

• similaritiesLa función de similitud que se utilizará. Puede usar las "cosine" "dotProduct" "euclidean" funciones de similitud, o. Especifique la función como un valor de cadena único 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 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, pase 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 usar 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, lo que indica a Django MongoDB Backend que solo 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 permiten evitar que los campos indexados almacenen valores duplicados. En un solo campo, los índices únicos garantizan que un valor aparezca como máximo una vez para el campo especificado. En varios campos, los índices únicos garantizan que cualquier combinación de valores de clave de í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"),
    ]