Migre seu aplicativo Djogo

Visão geral

Neste guia, você pode aprender como modificar seu projeto Djogo para usar o Django MongoDB Backend. O Djongo é uma biblioteca de terceiros que traduz queries SQL em queries da linguagem de query do MongoDB (MQL), permitindo que você use o MongoDB como seu backend do Django para as versões 4.0 e anteriores do Django. No entanto, o Django MongoDB Backend é a integração oficialmente suportada e oferece suporte ao Django mais abrangente, acesso expandido aos recursos do MongoDB e compatibilidade com versões mais recentes do Django.

Este guia mostra como migrar um aplicativo Djongo para o Django MongoDB backend atualizando os seguintes componentes do aplicativo:

• Configurações do Banco de Dados

• Aplicativos instalados

• Definições do modelo

• Indexes

• Consultas

• Migrações

Configurações do Banco de Dados

Para se conectar ao MongoDB usando o Django MongoDB Backend em vez do Djogo, modifique a configuração DATABASES no arquivo settings.py do seu aplicativo. Atualize o valor da chave ENGINE aninhada desta configuração de "djongo" para "django_mongodb_backend". Em seguida, especifique sua string de conexão na chave HOST aninhada em vez da chave 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'
    },
}

Aplicativos instalados

O Djogo não requer nenhuma configuração adicional dos aplicativos contrib integrados do Django. No entanto, o Django MongoDB Backend exige que cada aplicativo contrib que inclua modelos use ObjectIdAutoField como seu tipo de campo de chave primária padrão. Isso afeta os seguintes aplicativos:

• django.contrib.admin

• django.contrib.auth

• django.contrib.contenttypes

Para configurar estes aplicativos, crie ou atualize o arquivo apps.py no seu diretório de projeto para definir uma subclasse AppConfig personalizada para cada um dos aplicativos anteriores. O exemplo a seguir mostra um arquivo apps.py de amostra que define estas subclasses 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"

Em seguida, atualize a configuração INSTALLED_APPS em seu arquivo settings.py para usar suas classes AppConfig personalizadas em vez das classes padrão. O exemplo seguinte atualiza as configurações de um projeto denominado myproject para utilizar as classes AppConfig personalizadas. Selecione a aba Djongo para ver as configurações iniciais e selecione a aba Django MongoDB Backend para ver as configurações atualizadas:

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 fim, adicione a configuração MIGRATION_MODULES ao seu arquivo settings.py para instruir o Django MongoDB Backend a usar módulos de migração compatíveis com o MongoDB para os aplicativos contrib afetados:

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

python manage.py makemigrations
python manage.py migrate

Definições do modelo

Para atualizar seus modelos para usar o Backend do Django MongoDB , faça as seguintes alterações nas definições do seu modelo:

1. Importe o módulo models de django.db em vez de djongo.

2. Remova as definições explícitas de ObjectIdField, pois o Django MongoDB Backend cria automaticamente um campo _id do tipo ObjectIdField.

3. Modifique a sintaxe do array específica do MongoDB e dos campos incorporados.

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 atualizar os índices em seu aplicativo Djogo para compatibilidade com o Django MongoDB Backend, você deve usar as classes de índice fornecidas pelo Django MongoDB Backend.

O Djogo fornece classes separadas para representar cada índice do MongoDB , incluindo classes para índices de campo único, índices compostos, índices de múltiplas chaves e muito mais.

O Django MongoDB Backend fornece as três classes a seguir para representar todos os tipos de índice:

• Index classe: classe de índice do Django, que representa todos os tipos de índice que não são índices de pesquisa

• SearchIndex classe: A classe específica do Django MongoDB Backend para representar índices de pesquisa do MongoDB

• VectorSearchIndex classe: A Django MongoDB backend específica para representar índices de pesquisa do 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")
        ]

Consultas

Você pode usar a API do Django QuerySet para consultar os modelos backend do Djongo e do Django MongoDB. No entanto, a sintaxe é diferente para queries de modelo embarcado.

O Djogo trata modelos embarcados como dicionários Python, e você deve usar a sintaxe de dicionário Python para acessar ou modificar seus campos. O Django MongoDB backend trata os modelos incorporados como modelos Django, então você usa a mesma sintaxe para a interação com seus campos e com todos os outros modelos.

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

Recipe.objects.filter(nutrition__calories__lt=500)

Transações

Tanto o Djogo quanto o Django MongoDB Backend oferecem suporte à funcionalidade de API de transação atômica do Django. No entanto, cada um deles fornece uma API personalizada para implementar essa funcionalidade. Você pode atualizar suas transações para compatibilidade com o Django MongoDB Backend modificando a declaração de importação do seu código.

from djongo import transaction

from django_mongodb_backend import transaction

Migrações

O Djongo não suporta migrações de banco de dados e não impõe validação de esquema por padrão. Se você definir a configuração ENFORCE_SCHEMA para True em seu arquivo settings.py, o Djongo forçará MigrationErrors quando os documentos recuperados tiverem valores de campo ausentes.

O Django MongoDB backend oferece suporte a migrações de banco de dados com algumas limitações. Para saber mais sobre essas limitações, consulte suporte à migração no guia Compatibilidade de recursos.

O Django MongoDB Backend não impõe validação de esquema. Como resultado, atualizar campos de modelo sem executar migrações para atualizar o esquema do banco de dados não gera erros.

Informações adicionais

Para aprender como configurar um novo aplicativo que usa o backend do Django MongoDB, consulte o tutorial Introdução ao backend do Django MongoDB.

Para saber mais sobre como executar operações de banco de dados usando o Django MongoDB Backend, consulte o guia Operações CRUD.

Para **aprender** mais sobre como criar modelos de **backend** do **MongoDB** Django, consulte o **guia** Criar modelos para representar **coleções**.