Migra Tu 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 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 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 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. 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: 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 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 use Django MongoDB Backend, consulte el tutorial Introducción a 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.