/ /

Backend de Django MongoDB

Datos del modelo

Docs Home

Librerías de clientes

Python

Backend de Django MongoDB

Datos del modelo

Crear modelos para representar colecciones

Overview

En esta guía, puede aprender a crear modelos de Django que representen colecciones de MongoDB. Los modelos son clases de Python que definen la estructura de sus datos. Al usar Django MongoDB Backend, puedes asignar cada modelo a una colección de MongoDB e interactuar con los documentos de la colección utilizando objetos de modelo.

Tip

Para obtener más información sobre los modelos de Django, consulta Model en la documentación de Django.

Campos admitidos

Esta sección describe el soporte del Backend Django MongoDB para los siguientes campos, que puedes incluir en tus modelos:

Campos de Django
Campos BSON de MongoDB

Campos de Django

La siguiente tabla describe los campos del modelo Django que soporta Django MongoDB backend:

tipo de campo	Descripción
`BinaryField`	Almacena datos binary sin procesar.
`BooleanField`	Almacena valores booleanos (`True` o `False`).
`CharField`	Almacena valores de string. Para almacenar valores de texto más largos, utiliza `TextField`.
`DateField`	Almacena valores de fecha en instancias de Python `datetime.date`.
`DateTimeField`	Almacena valores de fecha y hora en instancias de Python `datetime.datetime` .
`DecimalField`	Almacena valores decimales.
`DurationField`	Almacena valores que representan períodos de tiempo en instancias de Python `timedelta`.
`EmailField`	Almacena `CharField` valores y utiliza un para verificar que el valor sea una dirección de correo `EmailValidator` electrónico.
`FileField`	Stores file values.
`FilePathField`	Se almacenan `CharField` valores que representan nombres de archivos en tu sistema de archivos.
`FloatField`	Stores float values.
`GenericIPAddressField`	Almacena una dirección IPv4 o IPv6 en formato de string.
`ImageField`	Almacena un valor `FileField` y verifica que el objeto subido sea una imagen válida.
`IntegerField` y `BigIntegerField`	Almacena valores enteros de hasta 64 bits de tamaño.
`JSONField`	Almacena datos JSON. Para obtener más información sobre este campo, consulte la sección «Almacenar datos JSON» de esta guía.
`PositiveIntegerField` y `PositiveBigIntegerField`	Almacena valores enteros positivos de hasta 64 bits de tamaño.
`PositiveSmallIntegerField`	Almacena valores enteros positivos de hasta 32 bits de tamaño.
`SlugField`	Almacena una etiqueta de texto corta, a menudo para valores de URL.
`SmallIntegerField`	Almacena valores enteros de hasta 32 bits de tamaño.
`TextField`	Almacena valores textuales grandes.
`URLField`	Almacena un valor `CharField` que representa una URL.
`UUIDField`	Almacena instancias de la clase `UUID` de Python.

Campos BSON de MongoDB

MongoDB organiza y almacena documentos en una representación binaria llamada BSON que permite un procesamiento de datos flexible.

Tip

Para obtener más información sobre cómo MongoDB almacena los datos BSON, consulta BSON Types en el manual de MongoDB Server.

La siguiente tabla describe los tipos de campo BSON compatibles y sus equivalentes en Django MongoDB Backend que puedes utilizar en tus modelos de Django:

Tipo de campo BSON	Django MongoDB Tipo de campo de backend	Descripción de BSON
`Array`	`ArrayField`	Almacena valores de matrices. Para obtener más información sobre cómo usar este campo con el backend de Django MongoDB, consulte la sección "Almacenar datos de matriz" en esta guía.
`Object`	`EmbeddedModelField` or `EmbeddedModelArrayField`	Almacena uno o varios documentos incrustados. Para obtener más información sobre cómo usar estos campos con Django MongoDB Backend, consulte las secciones «Almacenar datos de modelos incrustados» y «Almacenar datos de matrices de modelos incrustados».
`ObjectId`	`ObjectIdField`	Almacena identificadores únicos de 12bytes que MongoDB utiliza como claves primarias.
`Binary`	`BinaryField`	Almacena datos binary.
`Boolean`	`BooleanField`	Almacena valores de `true` o `false`.
`Date`	`DatetimeField`	Almacena fechas y horas en milisegundos desde la época Unix, o el 1 de enero de 1970.
`Decimal128`	`DecimalField`	Almacena valores decimales de 28bits.
`Double`	`FloatField`	Almacena valores de punto flotante.
`Int32`	`SmallIntegerField`	Almacena enteros de 32bits con signo.
`Int64`	`IntegerField` or `BigIntegerField`	Almacena enteros de 64bits con signo.
`String`	`CharField` or `TextField`	Almacena valores de string codificados en UTF-8.

Definir un Modelo

Para crear un modelo que represente una colección de MongoDB, agrega las definiciones de las clases de modelo al archivo models.py de la aplicación. En la clase del modelo, especifica los campos que deseas almacenar e incluye cualquier metadatos del modelo en una clase Meta interna. También se puede utilizar el método __str__() para definir la representación en string del modelo. Utiliza la siguiente sintaxis para definir un 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

Tip

Para obtener más información sobre las opciones de metadatos que puede especificar en la clase Meta, consulte opciones Meta del modelo en la documentación de Django.

Para utilizar tus modelos, debes agregarlos al archivo settings.py de tu proyecto. Edita el valor de INSTALLED_APPS para incluir el nombre del módulo que almacena tu archivo models.py, como se muestra en el siguiente código:

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

Finalmente, ejecutar los siguientes comandos de migración de base de datos desde el directorio raíz del Proyecto para crear colecciones de MongoDB para tus modelos o usar colecciones existentes para almacenar datos del modelo:

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

Ejemplo

Este archivo de muestra de models.py define una clase modelo de Movie que incluye la siguiente información:

Lista de campos que representan datos de películas.
Meta clase que establece la opción db_table en movies. Esto indica a Django MongoDB Backend que use este modelo para representar la colección sample_mflix.movies del Atlas muestra datasets.

La clase Meta también establece la opción managed en False, instruyendo a Django MongoDB Backend que no cree una nueva colección para el modelo.
__str__() método que define la representación en string del modelo como el valor de su 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

Tip

Para obtener más información sobre los campos utilizados en la definición de la clase de modelo, consulta la sección Campos compatibles de esta guía.

Utilizar los campos avanzados

Esta sección muestra cómo usar los siguientes campos en tus modelos de Django:

JSONField
Campo de matriz
EmbeddedModelField
EmbeddedModelArrayField
PolymorphicEmbeddedModelField
PolymorphicEmbeddedModelArrayField

Store JSON Data

Puede utilizar un JSONField en su modelo para almacenar objetos JSON. JSON es un formato legible por humanos para el intercambio de datos, y los objetos JSON son contenedores de datos que asignan claves de string a valores. MongoDB proporciona el tipo de campo Object para almacenar datos JSON en documentos y almacena internamente estos datos en BSON, o JSON binario.

Nota

También se pueden utilizar modelos integrados y modelos integrados polimórficos para representar un MongoDB Object.

Ejemplo

El siguiente ejemplo agrega un valor de JSONField al modelo creado en el Ejemplo de definición de un modelo de esta guía. El nuevo campo, llamado imdb, almacena datos JSON que representan las evaluaciones de usuarios 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

Tip

Para saber cómo consultar datos almacenados en un JSONField, consulta query de valores JSON en la guía Especificar una consulta.

Limitaciones

El soporte del Backend Django MongoDB para JSONField tiene las siguientes limitaciones:

Si configuraste el valor del campo en None, Django MongoDB Backend almacena su valor como un valor SQL NULL. De manera alternativa, puedes establecer el valor de JSONField en Value(None, JSONField()), que representa el escalar JSON null. Sin embargo, no hay manera de distinguir entre el SQL NULL y el JSON null al realizar consultas.
Algunas consultas que utilizan objetos Q pueden no devolver los resultados esperados, especialmente cuando se utiliza el método QuerySet.exclude().
Al consultar campos que tienen un valor None, el Backend Django MongoDB devuelve incorrectamente documentos en los que el campo no existe.

Almacenar datos de arreglo

Puedes usar un ArrayField en tu modelo para almacenar una lista de datos. Para crear un ArrayField, utilice el constructor de la clase ArrayField() y pase los siguientes argumentos:

base_fieldEspecifica el tipo de datos subyacente de cada valor almacenado en el arreglo. No se puede especificar EmbeddedModelField o FileField como tipo de campo base.
size: (Opcional) Especifica el tamaño máximo del arreglo.
options: (Opcional) Especifica las opciones de campo de Django. Para ver una lista de las opciones disponibles, consulta Opciones de campo en la documentación de Django.

Tip

Puedes almacenar un arreglo de valores de arreglos en un ArrayField utilizando la siguiente sintaxis:

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

Ejemplo

El siguiente ejemplo añade un valor ArrayField al modelo creado en el ejemplo Definir un Modelo de esta guía. El nuevo campo, denominado genres, almacena una lista de valores CharField que representan géneros cinematográficos y puede almacenar un 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

Tip

Para aprender cómo consultar datos almacenados en un ArrayField, consulta query arreglo Values en la guía Specify a query.

Almacenar datos de modelo embebido

Puedes usar un EmbeddedModelField para representar un Object MongoDB, el cual almacena un valor de documento anidado. Este tipo permite que un modelo almacene un modelo separado en uno de sus campos. Para crear un EmbeddedModelField, se debe definir una clase de modelo incrustado como una subclase del modelo abstracto EmbeddedModel. Luego, cree un campo en su clase de modelo base utilizando el constructor EmbeddedModelField() y pase los siguientes argumentos:

embedded_model": Especifica la clase de modelo a almacenar."
options: (Opcional) Especifica las opciones de campo de Django. Para ver una lista de las opciones disponibles, consulta Opciones de campo en la documentación de Django.

Importante

El comando Django makemigrations no detecta cambios en modelos embebidos. Si realizas cambios en la clase del modelo embebido, el modelo almacenado en el EmbeddedModelField no refleja los cambios.

Ejemplo

Este ejemplo agrega un valor EmbeddedModelField al modelo creado en el ejemplo de definición de modelo de esta guía. El nuevo campo, denominado awards, almacena un modelo Award incrustado como su valor. El siguiente código define el modelo Award y modifica el modelo Movie para incluir el 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

Tip

Para aprender cómo query datos almacenados en un EmbeddedModelField, consulta query valores de modelo embebido en la guía Especificar una query.

Almacenar Datos de arreglo de Modelos Integrados

Puedes usar un EmbeddedModelArrayField para representar un campo de documento MongoDB que almacena un arreglo de documentos en una relación uno a muchos. Cada documento en el arreglo corresponde a un valor de backend de Django MongoDB EmbeddedModelField. Para crear un EmbeddedModelArrayField, utiliza el constructor de la clase EmbeddedModelArrayField() y pasa los siguientes argumentos:

embedded_modelIndica el modelo almacenado en cada elemento del arreglo.
max_size: (Opcional) Especifica el tamaño máximo del arreglo.

Ejemplo

Este ejemplo añade un valor EmbeddedModelArrayField al modelo creado en el Ejemplo de Definir un Modelo en esta guía. Este campo cast almacena un arreglo de modelos Actor incrustados. El siguiente código define el modelo Actor y modifica el modelo Movie para incluir el 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

Almacenar datos de modelo embebido polimórfico

Puedes utilizar un PolymorphicEmbeddedModelField para representar un campo de documento de MongoDB que pueda almacenar múltiples tipos de documentos incrustados. Cada documento incrustado está representado por una clase de modelo de Django MongoDB Backend.

Para crear un PolymorphicEmbeddedModelField, pasa el argumento embedded_models al constructor de la clase PolymorphicEmbeddedModelField(). Este argumento especifica una lista de clases de modelo que el campo puede almacenar.

Ejemplo

Este ejemplo añade un valor PolymorphicEmbeddedModelField al modelo creado en el Ejemplo Definir un Modelo de esta guía. Este campo awards puede almacenar un modelo integrado de tipo Oscars o GoldenGlobes. Cada modelo integrado contiene información sobre todos los premios Oscar o Globos de Oro que ha ganado una película.

El siguiente código define los modelos integrados Oscars y GoldenGlobes, y luego modifica el modelo Movie para incluir el 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

Tip

Si deseas obtener información sobre cómo query los datos almacenados en PolymorphicEmbeddedModelField, consulta Valores del modelo integrado polimórfico en consultas en la guía Especificar una consulta.

Almacena datos del arreglo del modelo incrustado polimórfico

Se puede usar un PolymorphicEmbeddedModelArrayField para representar un campo de documento de MongoDB que pueda almacenar múltiples tipos de documentos incrustados. Este campo es similar al PolymorphicEmbeddedModelField, pero almacena un arreglo de documentos incrustados en lugar de un único documento. Cada documento incrustado en el arreglo está representado por una clase de modelo Django MongoDB backend.

Para crear un PolymorphicEmbeddedModelArrayField, pase los siguientes argumentos al constructor de la clase PolymorphicEmbeddedModelArrayField():

embedded_models- Especifica las clases de modelo que el campo puede almacenar
max_size: (Opcional) Especifica el tamaño máximo del arreglo

Ejemplo

Este ejemplo añade un valor PolymorphicEmbeddedModelArrayField al modelo creado en el Ejemplo Definir un Modelo de esta guía. Este campo awards puede almacenar una lista de modelos integrados de tipo Oscar o GoldenGlobe. Cada modelo integrado contiene información sobre un premio Oscar o Globo de Oro que ha ganado una película.

El siguiente código define los modelos integrados Oscar y GoldenGlobe, y luego modifica el modelo Movie para incluir el 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

Tip

Para aprender cómo consultar los datos almacenados en un PolymorphicEmbeddedModelArrayField, consulte Consultar valores de arreglos de modelo incrustado polimórfico en la guía Especificar una consulta.

Información Adicional

Para aprender a usar tus modelos para ejecutar operaciones en la base de datos, consulta las guías Interacción con datos.

Para obtener más información sobre los campos de Django, consulta la Referencia de campos de modelos en la documentación de Django.

Volver

Datos del modelo

Indexes