Join us Sept 17 at .local NYC! Use code WEB50 to save 50% on tickets. Learn more >
MongoDB Event
Menu Docs
Página inicial do Docs
/
Idiomas
/
Python
/
Backend do Django MongoDB
/
Modele seus dados

Criar modelos

Visão geral

Neste guia, você pode aprender como criar modelos Django que representam coleções MongoDB . Modelos são classes do Python que definem a estrutura dos seus dados. Ao usar o Django MongoDB Backend, você pode mapear cada modelo para uma coleção MongoDB e interagir com os documentos da coleção usando objetos de modelo.

Dica

Para saber mais sobre os modelos Django, consulte Model na documentação do Django.

Campos suportados

Esta seção descreve o suporte do Django MongoDB Backend para os seguintes campos, que você pode incluir em seus modelos:

Campos do Django

A tabela a seguir descreve os campos de modelo do Django que o Django MongoDB Backend suporta:

tipo de campo
Descrição

BigIntegerField

Stores IntegerField values up to 64 bits in size.

BinaryField

Stores raw binary data.

BooleanField

Stores boolean (True or False) values.

CharField

Stores string values. To store longer text values, use TextField.

DateField

Stores date values in Python datetime.date instances.

DateTimeField

Stores date and time values in Python datetime.datetime instances.

DecimalField

Stores decimal values.

DurationField

Stores values representing periods of time in Python timedelta instances.

EmailField

Stores CharField values and uses an EmailValidator to verify that the value is an email address.

FileField

Stores file values.

FilePathField

Stores CharField values that represent filenames on your filesystem.

FloatField

Stores float values.

GenericIPAddressField

Stores an IPv4 or IPv6 address in string format.

ImageField

Stores a FileField value and verifies that the uploaded object is a valid image.

IntegerField

Stores integer values up to 32 bits in size.

JSONField

Stores JSON data. To learn more about this field, see the Store JSON Data section in this guide.

PositiveBigIntegerField

Stores positive integer values up to 64 bits in size.

PositiveIntegerField

Stores positive integer values up to 32 bits in size.

PositiveSmallIntegerField

Stores positive integer values up to 16 bits in size.

SlugField

Stores a short text label, often for URL values.

SmallIntegerField

Stores integer values up to 16 bits in size.

TextField

Stores large text values.

URLField

Stores a CharField value representing a URL.

UUIDField

Stores instances of Python's UUID class.

Campos JSON do MongoDB

O MongoDB organiza e armazena documentos em uma representação binária chamada BSON que permite o processamento de dados flexível.

Dica

Para saber mais sobre como o MongoDB armazena dados BSON, consulte tipos de BSON no manual do MongoDB Server .

A tabela a seguir descreve os tipos de campo BSON compatíveis e seus equivalentes no Django MongoDB Backend que você pode usar em seus modelos do Django:

Tipo de campo BSON
Tipo de campo de backend do Django MongoDB
Descrição do JSON

Array

ArrayField

Stores array values. To learn more about using this field with Django MongoDB Backend, see the Store Array Data section in this guide.

Object

EmbeddedModelField ou EmbeddedModelArrayField

Stores one or multiple embedded documents. To learn more about using these fields with Django MongoDB Backend, see the Store Embedded Model Data and Store Embedded Model Array Data sections.

ObjectId

ObjectIdField

Stores unique 12-byte identifiers that MongoDB uses as primary keys.

Binary

BinaryField

Stores binary data.

Boolean

BooleanField

Stores true or false values.

Date

DatetimeField

Stores dates and times in milliseconds since the Unix epoch, or January 1, 1970.

Decimal128

DecimalField

Stores 28-bit decimal values.

Double

FloatField

Stores floating-point values.

Int32

IntegerField

Stores 32-bit signed integers.

Int64

IntegerField ou BigIntegerField

Stores 64-bit signed integers.

String

CharField ou TextField

Stores UTF-8 encoded string values.

Definir um modelo

Para criar um modelo que represente uma collection do MongoDB , adicione as definições da classe do modelo ao arquivo models.py do aplicativo. Em sua classe de modelo, especifique os campos que você deseja armazenar e inclua quaisquer metadados de modelo em uma classe Meta interna. Você também pode usar o método __str__() para definir a representação de string do seu modelo. Use a seguinte sintaxe para definir um modelo:

 class <Model name>(models.Model):
     <field name> = <data type>
     # Include additional fields here
     class Meta:
         # Include metadata here
     def __str__(self):
         # Include logic for displaying your model as a string here

Dica

Para saber mais sobre as opções de metadados que você pode especificar na Meta classe, consulte Opções de metadados do modelo na documentação do Django.

Para utilizar seus modelos, você deve adicioná-los ao arquivo settings.py do seu projeto. Edite o valor INSTALLED_APPS para incluir o nome do módulo que armazena seu arquivo models.py, conforme mostrado no código a seguir:

 INSTALLED_APPS = [
     '<application module>',
     # Include other app modules here
 ]

Por fim, execute os seguintes comandos de migração de banco de dados a partir do diretório raiz do seu projeto para criar coleções MongoDB para seus modelos ou utilize coleções existentes para armazenar dados do modelo:

python manage.py makemigrations <application name>
python manage.py migrate

Exemplo

Este arquivo models.py de amostra define uma classe de modelo Movie que inclui as seguintes informações:

  • Lista de campos que representam dados de filme.

  • Meta classe que define a opção db_table como movies. Isto instrui o Backend do Django MongoDB a utilizar este modelo para representar a sample_mflix.movies coleção do a partir dos conjuntos de dados de amostra do Atlas .

    A classe Meta também define a opção managed como False, instruindo o Django MongoDB Backend a não criar uma nova collection para o modelo.

  • __str__() que define a representação de string do modelo como seu valor de campo title.

from django.db import models
class Movie(models.Model):
    title = models.CharField(max_length=200)
    plot = models.TextField(blank=True)
    runtime = models.IntegerField(default=0)
    released = models.DateTimeField("release date", null=True, blank=True)
    class Meta:
        db_table = "movies"
        managed = False
    
    def __str__(self):
        return self.title

Dica

Para saber mais sobre os campos usados na definição da classe de modelo, consulte a seção Campos compatíveis deste guia.

Usar campos avançados

Esta seção mostra como usar os seguintes campos em seus modelos Django:

Store JSON Data

Você pode utilizar um JSONField em seu modelo para armazenar objetos JSON. O JSON é um formato legível por humanos para troca de dados, e os objetos JSON são contêineres de dados que mapeiam chaves de string para valores. O MongoDB fornece o tipo de campo Object para armazenar dados JSON em documentos e armazena internamente esses dados no formato BSON ou Binary JSON.

Observação

Você também pode utilizar modelos embarcados e modelos embarcados polimórficos para representar um MongoDB Object.

Exemplo

O exemplo a seguir adiciona um JSONField valor ao modelo criado no exemplo Definir um modelo neste guia. O novo campo, chamado imdb, armazena dados JSON que representam classificações de usuários para cada objeto Movie:

from django.db import models
class Movie(models.Model):
    title = models.CharField(max_length=200)
    plot = models.TextField(blank=True)
    runtime = models.IntegerField(default=0)
    released = models.DateTimeField("release date", null=True, blank=True)
    imdb = models.JSONField(null=True, blank=True)
    class Meta:
        db_table = "movies"
        managed = False
    
    def __str__(self):
        return self.title

Dica

Para aprender como consultar dados armazenados em um JSONField, consulte Consultar Valores JSON no guia Especificar uma query.

Limitações

O suporte do Django MongoDB Backend para JSONField tem as seguintes limitações:

  • Se você definir o valor do campo como None, o Backend do Django MongoDB armazenará seu valor como um valor SQL NULL. Como alternativa, você pode definir o valor JSONField como Value(None, JSONField()), que representa o null escalar JSON. No entanto, não há como distinguir entre o SQL NULL e o JSON null ao fazer query.

  • Algumas queries que utilizam objetos Q podem não retornar os resultados esperados, especialmente ao utilizar o método QuerySet.exclude().

  • Ao executar query de campos que têm um valor de None, o Django MongoDB Backend retorna incorretamente documentos nos quais o campo não existe.

Armazenar dados de array

Você pode utilizar um ArrayField em seu modelo para armazenar uma lista de dados. Para criar um ArrayField, utilize o construtor de classe ArrayField() e passe os seguintes argumentos:

  • base_field: especifica o tipo de dados subjacente de cada valor armazenado na array. Você não pode especificar EmbeddedModelField ou FileField como o tipo de campo base.

  • size: (Opcional) Especifica o tamanho máximo da array.

  • options: (Opcional) Especifica as opções de campo do Django. Para visualizar uma lista de opções disponíveis, consulte Opções de campo na documentação do Django.

Dica

Você pode armazenar uma array de valores de array em um ArrayField usando a seguinte sintaxe:

my_array = ArrayField(
      ArrayField(
          base_field,
          # ... Additional arguments
      ),
)

Exemplo

O exemplo a seguir adiciona um ArrayField valor de ao modelo criado no exemplo Definir um modelo neste guia. O novo campo, chamado genres, armazena uma lista de CharField valores que representam gêneros de filmes e podem armazenar um máximo de 5 valores:

from django.db import models
from django_mongodb_backend.fields import ArrayField
class Movie(models.Model):
    title = models.CharField(max_length=200)
    plot = models.TextField(blank=True)
    runtime = models.IntegerField(default=0)
    released = models.DateTimeField("release date", null=True, blank=True)
    genres = ArrayField(
             models.CharField(max_length=100),
             size=5,
             null=True,
             blank=True)
    class Meta:
        db_table = "movies"
        managed = False
    
    def __str__(self):
        return self.title

Dica

Para aprender como consultar dados armazenados em um ArrayField, consulte Valores de Matriz de Query no guia Especificar uma query.

Armazenar dados de modelo incorporados

Você pode usar um EmbeddedModelField para representar um MongoDB Object, que armazena um valor de documento aninhado. Este tipo permite que um modelo armazene um modelo separado em um de seus campos. Para criar um EmbeddedModelField, defina uma classe de modelo embarcado como uma subclasse do modelo abstrato EmbeddedModel. Em seguida, crie um campo na classe do modelo base usando o construtor EmbeddedModelField() e passe os seguintes argumentos:

  • embedded_model: especifica a classe de modelo a ser armazenada.

  • options: (Opcional) Especifica as opções de campo do Django. Para visualizar uma lista de opções disponíveis, consulte Opções de campo na documentação do Django.

Importante

O comando makemigrations Django não detecta alterações em modelos incorporados. Se você fizer alterações na classe do modelo embarcado, o modelo armazenado no EmbeddedModelField não refletirá as alterações.

Exemplo

Este exemplo adiciona um EmbeddedModelField valor ao modelo criado no exemplo Definir um modelo neste guia. O novo campo, chamado awards, armazena um modelo Award incorporado como seu valor. O seguinte código define o modelo Award e modifica o modelo Movie para incluir o EmbeddedModelField:

from django.db import models
from django_mongodb_backend.models import EmbeddedModel
from django_mongodb_backend.fields import EmbeddedModelField
class Award(EmbeddedModel):
    wins = models.IntegerField(default=0)
    nominations = models.IntegerField(default=0)
    text = models.CharField(max_length=100)
class Movie(models.Model):
    title = models.CharField(max_length=200)
    plot = models.TextField(blank=True)
    runtime = models.IntegerField(default=0)
    released = models.DateTimeField("release date", null=True, blank=True)
    awards = EmbeddedModelField(Award, null=True, blank=True)
    class Meta:
        db_table = "movies"
        managed = False
    
    def __str__(self):
        return self.title

Dica

Para aprender como consultar dados armazenados em um EmbeddedModelField, consulte Consultar Valores de Modelo Incorporados no guia Especificar uma Query.

Armazenar dados de array do modelo incorporado

Você pode usar um EmbeddedModelArrayField para representar um campo de documento do MongoDB que armazena uma array de documentos em um relacionamento de um para muitos. Cada documento na array corresponde a um valor Django MongoDB Backend EmbeddedModelField. Para criar um EmbeddedModelArrayField, utilize o construtor de classe EmbeddedModelArrayField() e passe os seguintes argumentos:

  • embedded_model: Especifica o modelo armazenado em cada item da array.

  • max_size: (Opcional) Especifica o tamanho máximo da array.

Exemplo

Este exemplo adiciona um valor EmbeddedModelArrayField ao modelo criado no exemplo Definir um modelo neste guia. Este campo cast armazena uma array de modelos Actor incorporados. O seguinte código define o modelo Actor e modifica o modelo Movie para incluir o EmbeddedModelArrayField:

from django.db import models
from django_mongodb_backend.models import EmbeddedModel
from django_mongodb_backend.fields import EmbeddedModelArrayField
class Actor(EmbeddedModel):
    first_name = models.CharField(max_length=100)
    last_name = models.CharField(max_length=100)
    role = models.CharField(max_length=100)
class Movie(models.Model):
    title = models.CharField(max_length=200)
    plot = models.TextField(blank=True)
    runtime = models.IntegerField(default=0)
    released = models.DateTimeField("release date", null=True, blank=True)
    cast = EmbeddedModelArrayField(Actor, null=True, blank=True)
    class Meta:
        db_table = "movies"
        managed = False
    
    def __str__(self):
        return self.title

Armazenar dados de modelo incorporado polimórfico

Você pode usar um PolymorphicEmbeddedModelField para representar um campo de documento MongoDB que pode armazenar vários tipos de documentos incorporados. Cada documento incorporado é representado por uma classe de modelo do Django MongoDB Backend .

Para criar um PolymorphicEmbeddedModelField, passe o argumento embedded_models para o construtor da classe PolymorphicEmbeddedModelField() . Este argumento especifica uma lista de classes de modelo que o campo pode armazenar.

Exemplo

Este exemplo adiciona um valor PolymorphicEmbeddedModelField ao modelo criado no exemplo Definir um modelo neste guia. Este campo do awards pode armazenar um modelo embarcado do tipo Oscars ou GoldenGlobes. Cada modelo incorporado contém informações sobre todos os prêmios Oscar ou Globo de Dourado que um filme ganha.

O seguinte código define os modelos embarcados Oscars e GoldenGlobes e, em seguida, modifica o modelo Movie para incluir o PolymorphicEmbeddedModelField:

from django.db import models
from django_mongodb_backend.models import EmbeddedModel
from django_mongodb_backend.fields import PolymorphicEmbeddedModelField
class Oscars(EmbeddedModel):
    wins = models.IntegerField(default=0)
    nominations = models.IntegerField(default=0)
    best_picture = models.BooleanField(default=False)
class GoldenGlobes(EmbeddedModel):
    wins = models.IntegerField(default=0)
    nominations = models.IntegerField(default=0)
class Movie(models.Model):
    title = models.CharField(max_length=200)
    plot = models.TextField(blank=True)
    runtime = models.IntegerField(default=0)
    released = models.DateTimeField("release date", null=True, blank=True)
    awards = PolymorphicEmbeddedModelField(["Oscars", "GoldenGlobes"], null=True, blank=True)
    class Meta:
        db_table = "movies"
        managed = False
    
    def __str__(self):
        return self.title

Dica

Para aprender como executar queries de dados armazenados em um PolymorphicEmbeddedModelField, consulte Consultar valores de modelo incorporados polimórficos no guia Especificar uma query.

Armazenar dados de array de modelo polimórfico incorporado

Você pode usar um PolymorphicEmbeddedModelArrayField para representar um campo de documento MongoDB que pode armazenar vários tipos de documentos incorporados. Este campo é semelhante ao PolymorphicEmbeddedModelField, mas armazena uma array de documentos incorporados em vez de um único documento. Cada documento incorporado na array é representado por uma classe de modelo Django MongoDB Backend .

Para criar um PolymorphicEmbeddedModelArrayField, passe os seguintes argumentos para o construtor da classe PolymorphicEmbeddedModelArrayField():

  • embedded_models: Especifica as classes de modelo que o campo pode armazenar

  • max_size: (Opcional) Especifica o tamanho máximo da array

Exemplo

Este exemplo adiciona um valor PolymorphicEmbeddedModelArrayField ao modelo criado no exemplo Definir um modelo neste guia. Este campo do awards pode armazenar uma lista de modelos embarcados do tipo Oscar ou GoldenGlobe. Cada modelo incorporado contém informações sobre um dos prêmios Oscar ou Globo de Dourado que um filme lhe rendeu.

O seguinte código define os modelos embarcados Oscar e GoldenGlobe e, em seguida, modifica o modelo Movie para incluir o PolymorphicEmbeddedModelArrayField:

from django.db import models
from django_mongodb_backend.models import EmbeddedModel
from django_mongodb_backend.fields import PolymorphicEmbeddedModelArrayField
class Oscar(EmbeddedModel):
    category = models.CharField(max_length=200)
    year = models.IntegerField(default=0)
class GoldenGlobe(EmbeddedModel):
    category = models.CharField(max_length=200)
    year = models.IntegerField(default=0)
class Movie(models.Model):
    title = models.CharField(max_length=200)
    plot = models.TextField(blank=True)
    runtime = models.IntegerField(default=0)
    released = models.DateTimeField("release date", null=True, blank=True)
    awards = PolymorphicEmbeddedModelArrayField(["Oscar", "GoldenGlobe"], null=True, blank=True)
    class Meta:
        db_table = "movies"
        managed = False
    
    def __str__(self):
        return self.title

Dica

Para saber como executar queries de dados armazenados em um PolymorphicEmbeddedModelArrayField, consulte Consultar valores de array de modelo polimórfico incorporado no guia Especificar uma query.

Informações adicionais

Para saber como usar seus modelos para executar operações de banco de dados , consulte os guias Interagir com dados.

Para saber mais sobre os campos do Django, consulte a referência de campo do Modelo na documentação do Django.

Voltar

Crie índices

Próximo

Dados geoespaciais do modelo

Nesta página