Migra Tu Aplicación Djongo

Overview

En esta guía, puedes aprender cómo modificar tu proyecto Djongo para usar Backend Django MongoDB. Djongo es una librería de terceros que traduce consultas SQL en consultas MQL (MongoDB Query Language), permitiéndote usar MongoDB como tu backend para Django en versiones 4.0 y anteriores. Sin embargo, Django MongoDB Backend es la integración oficialmente soportada y ofrece soporte más completo para Django, acceso ampliado a las funcionalidades de MongoDB y compatibilidad con 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

• Aplicaciones instaladas

• Definiciones de modelos

• Indexes

• Queries

• migración

Configuración de la base de datos

Para conectarse a MongoDB usando Django MongoDB Backend en vez de Djongo, modifique el DATABASES configuración en el archivo settings.py de tu aplicación. Actualiza el valor de la clave anidada ENGINE de esta configuración de "djongo" a "django_mongodb_backend". Luego, especifique su cadena de conexión en la clave anidada HOST 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'
    },
}

Aplicaciones instaladas

Djongo no requiere ninguna configuración adicional de las aplicaciones integradas contrib de Django. Sin embargo, Django MongoDB backend requiere que cada aplicación contrib que incluya modelos use ObjectIdAutoField como su tipo de campo de llave primaria por defecto. Esto afecta a las siguientes aplicaciones:

• django.contrib.admin

• django.contrib.auth

• django.contrib.contenttypes

Para configurar estas aplicaciones, crea o actualiza el archivo apps.py en el directorio de tu proyecto para definir una subclase AppConfig personalizada para cada una de las aplicaciones anteriores. El siguiente ejemplo muestra un archivo de ejemplo apps.py que define estas subclases AppConfig:

from django.contrib.admin.apps import AdminConfig
from django.contrib.auth.apps import AuthConfig
from django.contrib.contenttypes.apps import ContentTypesConfig
class MongoAdminConfig(AdminConfig):
    default_auto_field = "django_mongodb_backend.fields.ObjectIdAutoField"
class MongoAuthConfig(AuthConfig):
    default_auto_field = "django_mongodb_backend.fields.ObjectIdAutoField"
class MongoContentTypesConfig(ContentTypesConfig):
    default_auto_field = "django_mongodb_backend.fields.ObjectIdAutoField"

Luego, actualiza la configuración de INSTALLED_APPS en tu archivo settings.py para usar tus clases personalizadas de AppConfig en lugar de las clases por defecto. El siguiente ejemplo actualiza la configuración de un proyecto llamado myproject para usar las clases AppConfig personalizadas. Selecciona la pestaña Djongo para ver la configuración inicial y selecciona la pestaña Django MongoDB Backend para ver la configuración actualizada:

INSTALLED_APPS = [
    'myapp.apps.MyAppConfig',
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
]

INSTALLED_APPS = [
    'myapp.apps.MyAppConfig',
    'myproject.apps.MongoAdminConfig',
    'myproject.apps.MongoAuthConfig',
    'myproject.apps.MongoContentTypesConfig',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'django_mongodb_backend',
]

Por último, añade la configuración MIGRATION_MODULES a tu archivo settings.py para indicar a Django MongoDB Backend que utilice módulos de migración compatibles con MongoDB para las apps contrib afectadas:

MIGRATION_MODULES = {
    'admin': 'mongo_migrations.admin',
    'auth': 'mongo_migrations.auth',
    'contenttypes': 'mongo_migrations.contenttypes',
}

python manage.py makemigrations
python manage.py migrate

Definiciones de modelos

Para actualizar tus modelos para usar Django MongoDB Backend, realiza los siguientes cambios en las definiciones de tu modelo:

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

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

3. Modifica la sintaxis de los campos de tipo arreglo y embebidos específicos de MongoDB.

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 usar las clases de índices proporcionadas por Django MongoDB Backend.

Djongo proporciona clases separadas para representar cada índice de MongoDB, incluyendo clases para índices de un solo campo, índices compuestos, índices multiclave y más.

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

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

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

• VectorSearchIndex class: una clase específica de Django MongoDB Backend para representar los índices de MongoDB Vector Search

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 utilizar la API QuerySet de Django para consultar tanto los modelos de Djongo como los del backend MongoDB de Django. Sin embargo, la sintaxis difiere para las queries de modelos incrustados.

Djongo trata los modelos embebidos 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 intregado como modelos de Django, por lo que usas la misma sintaxis para interactuar con sus campos que con todos los demás modelos.

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

Recipe.objects.filter(nutrition__calories__lt=500)

Transacciones

Tanto Djongo como Django MongoDB Backend admiten la funcionalidad de 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 Django MongoDB Backend modificando la instrucción de importación en tu código.

from djongo import transaction

from django_mongodb_backend import transaction

migración

Djongo no admite migraciones de bases de datos y no aplica la validación de esquemas por defecto. Si configuras la opción ENFORCE_SCHEMA en True en tu archivo settings.py, Djongo aplica MigrationErrors cuando los documentos recuperados tienen valores de campos faltantes.

Django MongoDB Backend admite migraciones de bases de datos con algunas limitaciones. Para obtener más información sobre estas limitaciones, consulta Soporte de migración en la guía de Compatibilidad de funcionalidades.

El Backend de Django MongoDB no aplica la validación de esquemas. Como resultado, 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, consulta el tutorial Empezar con Django MongoDB Backend.

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

Para aprender más sobre cómo crear modelos de Backend Django MongoDB, consulta la guía Crear modelos para representar colecciones.