Migrar su aplicación Djongo

Overview

En esta guía, aprenderá a modificar su proyecto Djongo para usar Django MongoDB Backend. Djongo es una biblioteca de terceros que traduce consultas SQL a consultas MQL (lenguaje de consulta MongoDB), lo que le permite usar MongoDB como backend para las versiones 4.0 y anteriores. Sin embargo, Django MongoDB Backend es la integración oficialmente compatible y ofrece un soporte más completo para Django, mayor acceso a las funciones de MongoDB y compatibilidad con las versiones más recientes de Django.

Esta guía muestra cómo migrar una aplicación Djongo a Django MongoDB Backend actualizando los siguientes componentes de la aplicación:

• Configuración de la base de datos

• Definiciones del modelo

• Indexes

• Queries

• Migraciones

Configuración de la base de datos

Para conectarse a MongoDB usando Django MongoDB Backend en lugar de Djongo, modifique el DATABASES Ajuste en el archivo settings.py de su aplicación. Actualice el valor de la clave ENGINE anidada de este ajuste de "djongo" a "django_mongodb_backend". A continuación, especifique la cadena de conexión en la clave HOST anidada en lugar de la clave CLIENT.

DATABASES = {
    'default': {
        'ENGINE': 'djongo',
        'CLIENT': {
            'host': 'mongodb+srv://cluster0.example.mongodb.net',
        },
        'NAME': 'my_database'
    }
}

DATABASES = {
    'default': {
        'ENGINE': 'django_mongodb_backend',
        'HOST': 'mongodb+srv://cluster0.example.mongodb.net',
        'NAME': 'my_database'
    },
}

Definiciones del modelo

Para actualizar sus modelos para usar Django MongoDB Backend, realice los siguientes cambios en las definiciones de sus modelos:

1. Importe el módulo models desde django.db en lugar de desde djongo.

2. Elimine las definiciones explícitas ObjectIdField, porque Django MongoDB Backend crea automáticamente un campo _id de tipo ObjectIdField.

3. Modificar la sintaxis de la matriz específica de MongoDB y los campos incrustados.

from djongo import models
class Tag(models.Model):
    data = models.CharField(max_length=100)
    class Meta:
        abstract = True
class Recipe(models.Model):
    _id = models.ObjectIdField()
    title = models.CharField(max_length=100)
    cuisine = models.CharField(max_length=100)
    cook_time = models.IntegerField(default=0)
    tags = models.ArrayField(model_container=Tag)

from django.db import models
from django_mongodb_backend.fields import ArrayField
class Recipe(models.Model):
    title = models.CharField(max_length=100)
    cuisine = models.CharField(max_length=100)
    cook_time = models.IntegerField(default=0)
    tags = ArrayField(
             models.CharField(max_length=100),
             size=4,
             null=True,
             blank=True)

Recipe.objects.create(
    title="Tiramisu",
    cuisine="Italian",
    cook_time=20,
    tags=[
        {"data": "dessert"},
        {"data": "classic"},
        {"data": "espresso"},
        {"data": "chocolate"}
    ]
)

Recipe.objects.create(
    title="Tiramisu",
    cuisine="Italian",
    cook_time=20,
    tags=["dessert", "classic", "espresso", "chocolate"]
)

from djongo import models
class Nutrition(models.Model):
    calories = models.IntegerField(default=0)
    carb_grams = models.IntegerField(default=0)
    protein_grams = models.IntegerField(default=0)
    class Meta:
        abstract = True
class Review(models.Model):
    author = models.CharField(max_length=100)
    rating = models.IntegerField(default=0)
    class Meta:
        abstract = True
class Recipe(models.Model):
    _id = models.ObjectIdField()
    title = models.CharField(max_length=100)
    cuisine = models.CharField(max_length=100)
    cook_time = models.IntegerField(default=0)
    nutrition = models.EmbeddedField(model_container=Nutrition)
    reviews = models.ArrayField(model_container=Review)

from django.db import models
from django_mongodb_backend.models import EmbeddedModel
from django_mongodb_backend.fields import EmbeddedModelField, EmbeddedModelArrayField
class Nutrition(EmbeddedModel):
    calories = models.IntegerField(default=0)
    carb_grams = models.IntegerField(default=0)
    protein_grams = models.IntegerField(default=0)
class Review(EmbeddedModel):
    author = models.CharField(max_length=100)
    rating = models.IntegerField(default=0)
class Recipe(models.Model):
    title = models.CharField(max_length=100)
    cuisine = models.CharField(max_length=100)
    cook_time = models.IntegerField(default=0)
    nutrition = EmbeddedModelField(Nutrition, null=True, blank=True)
    reviews = EmbeddedModelArrayField(Review, null=True, blank=True)

Indexes

Para actualizar los índices en su aplicación Djongo para la compatibilidad con Django MongoDB Backend, debe utilizar las clases de índice proporcionadas por Django MongoDB Backend.

Djongo proporciona clases separadas para representar cada índice de MongoDB, incluidas clases para índices de campo único, índices compuestos, índices de múltiples claves y más.

Django MongoDB Backend proporciona las siguientes tres clases para representar todos los tipos de índices:

• Index clase: clase de índice de Django, que representa todos los tipos de índice que no son de búsqueda

• SearchIndex clase: Una clase específica de Django MongoDB Backend para representar los índices de búsqueda de MongoDB

• VectorSearchIndex clase: Una clase específica de Django MongoDB Backend para representar índices de búsqueda vectorial de MongoDB

from djongo import models
from djongo.models.indexes import CompoundIndex
class Recipe(models.Model):
    _id = models.ObjectIdField()
    title = models.CharField(max_length=100)
    cuisine = models.CharField(max_length=100)
    cook_time = models.IntegerField(default=0)
    class Meta:
        indexes = [
            CompoundIndex(fields=["title", "cook_time"])
        ]

from django.db import models
from django_mongodb_backend.indexes import SearchIndex
class Recipe(models.Model):
    title = models.CharField(max_length=100)
    cuisine = models.CharField(max_length=100)
    cook_time = models.IntegerField(default=0)
    class Meta:
        indexes = [
            models.Index(fields=["title", "cook_time"]),
            SearchIndex(fields=["cuisine"], name="cuisine_search_idx")
        ]

Queries

Puedes usar la API de Django QuerySet para consultar los modelos backend de Djongo y Django MongoDB. Sin embargo, la sintaxis difiere para las consultas de modelos incrustados.

Djongo trata los modelos incrustados como diccionarios de Python, y se debe usar la sintaxis de diccionario de Python para acceder o modificar sus campos. Django MongoDB Backend trata los modelos incrustados como modelos de Django, por lo que se usa la misma sintaxis para interactuar con sus campos que con los demás modelos.

Recipe.objects.filter(nutrition__lt={'calories': 500})

Recipe.objects.filter(nutrition__calories__lt=500)

Transacciones

Tanto Djongo como el backend de Django MongoDB son compatibles con la API de transacciones atómicas de Django. Sin embargo, cada uno proporciona una API personalizada para implementar esta funcionalidad. Puedes actualizar tus transacciones para que sean compatibles con el backend de Django MongoDB modificando la declaración de importación de tu código.

from djongo import transaction

from django_mongodb_backend import transaction

Migraciones

Djongo no admite migraciones de bases de datos ni aplica la validación de esquemas de forma predeterminada. Si configura el valor ENFORCE_SCHEMA en True en su archivo settings.py, Djongo aplica MigrationErrors cuando faltan valores de campo en los documentos recuperados.

El backend de Django MongoDB admite migraciones de bases de datos con algunas limitaciones. Para obtener más información sobre estas limitaciones, consulte "Soporte de migración" en la guía de compatibilidad de funciones.

El backend de Django MongoDB no aplica la validación del esquema. Por lo tanto, actualizar los campos del modelo sin ejecutar migraciones para actualizar el esquema de la base de datos no genera errores.

Información Adicional

Para aprender a configurar una nueva aplicación que utiliza Django MongoDB Backend, consulte el tutorial Primeros pasos.

Para obtener más información sobre cómo ejecutar operaciones de base de datos mediante Django MongoDB Backend, consulte la guía Realizar operaciones CRUD.

Para obtener más información sobre la creación de modelos Django MongoDB Backend, consulte la guía Crear modelos.