/ /

Backend de Django MongoDB

Modele sus datos

Docs Home

Librerías de clientes

Python

Backend de Django MongoDB

Modele sus datos

Crear modelos

Overview

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

Tip

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

Campos admitidos

Esta sección describe el soporte de Django MongoDB Backend 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 Django MongoDB Backend admite:

Tipo de campo	Descripción
`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` y `BigIntegerField`	Stores integer values up to 64 bits in size.
`JSONField`	Stores JSON data. To learn more about this field, see the Store JSON Data section in this guide.
`PositiveIntegerField` y `PositiveBigIntegerField`	Stores positive integer values up to 64 bits in size.
`PositiveSmallIntegerField`	Stores positive integer values up to 32 bits in size.
`SlugField`	Stores a short text label, often for URL values.
`SmallIntegerField`	Stores integer values up to 32 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 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 datos BSON, consulte Tipos BSON en el manual del servidor MongoDB.

La siguiente tabla describe los tipos de campos BSON admitidos y sus equivalentes de Django MongoDB Backend que puede usar en sus modelos de Django:

Tipo de campo BSON	Tipo de campo de backend de Django MongoDB	Descripción de BSON
`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` or `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`	`SmallIntegerField`	Stores 32-bit signed integers.
`Int64`	`IntegerField` or `BigIntegerField`	Stores 64-bit signed integers.
`String`	`CharField` or `TextField`	Stores UTF-8 encoded string values.

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 Meta clase, consulte Opciones de metadatos del modelo en la documentación de Django.

Para usar sus modelos, debe agregarlos al archivo settings.py de su proyecto. Edite el valor INSTALLED_APPS para incluir el nombre del módulo que almacena su archivo models.py, como se muestra en el siguiente código:

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

Por último, ejecute los siguientes comandos de migración de base de datos desde el directorio raíz de su proyecto para crear colecciones de MongoDB para sus modelos o utilizar colecciones existentes para almacenar datos de modelos:

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

Ejemplo

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

Lista de campos que representan datos de películas.
Meta Clase que establece la db_table opción movies en. Esto indica al backend de Django MongoDB que use este modelo para representar la sample_mflix.movies colección de los conjuntos de datos de muestra de Atlas.
La clase Meta también establece la opción managed en False, lo que le indica a Django MongoDB Backend que no cree una nueva colección para el modelo.
__str__() método que define la representación de cadena del modelo como su 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

Tip

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

Utilizar campos avanzados

Esta sección muestra cómo utilizar los siguientes campos en sus modelos de Django:

Campo JSON
Campo de matriz
Campo de modelo incrustado
Campo de matriz de modelos incrustados
Campo de modelo incrustado polimórfico
Campo de matriz de modelo incrustado polimórfico

Store JSON Data

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

Nota

También puede 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 aprender a consultar datos almacenados en un,JSONField consulte Consultar valores JSON en la guía Especificar una consulta.

Limitaciones

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

Si establece el valor del campo en None, Django MongoDB Backend lo almacena como un valor SQL NULL. Como alternativa, puede establecer el valor JSONField en Value(None, JSONField()), que representa el escalar JSON null. Sin embargo, no es posible distinguir entre el valor SQL NULL y el JSON null al realizar consultas.
Algunas consultas que utilizan objetos Q podrían no devolver los resultados esperados, especialmente cuando se utiliza el método QuerySet.exclude().
Al consultar campos que tienen un valor None, Django MongoDB Backend devuelve incorrectamente documentos en los que el campo no existe.

Almacenar datos de matriz

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

base_field: Especifica el tipo de dato subyacente de cada valor almacenado en la matriz. No se puede especificar EmbeddedModelField ni FileField como tipo de campo base.
size: (Opcional) Especifica el tamaño máximo de la matriz.
options: (Opcional) Especifica las opciones de campo de Django. Para ver la lista de opciones disponibles, consulte "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 ArrayField valor al modelo creado en el ejemplo "Definir un modelo" de esta guía. El nuevo campo,genres llamado, almacena una lista de CharField valores 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 a consultar datos almacenados en un,ArrayField consulte Consultar valores de matriz en la guía Especificar una consulta.

Almacenar datos de modelo embebido

Puede usar un EmbeddedModelField para representar un Object de MongoDB, que almacena un valor de documento anidado. Este tipo permite que un modelo almacene un modelo independiente en uno de sus campos. Para crear un EmbeddedModelField, defina una clase de modelo incrustada como subclase del modelo abstracto EmbeddedModel. A continuación, cree un campo en su clase de modelo base mediante 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 la lista de opciones disponibles, consulte "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 añade un EmbeddedModelField valor al modelo creado en el ejemplo "Definir un modelo" de esta guía. El nuevo campo,awards llamado, almacena un Award modelo incrustado como su valor. El siguiente código define el Award modelo y modifica el Movie modelo para incluir EmbeddedModelField el:

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 a consultar datos almacenados en un,EmbeddedModelField consulte Consultar valores de modelos integrados en la guía Especificar una consulta.

Almacenar datos de matriz de modelos integrados

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

embedded_model: Especifica el modelo almacenado en cada elemento de la matriz.
max_size: (Opcional) Especifica el tamaño máximo de la matriz.

Ejemplo

Este ejemplo añade un EmbeddedModelArrayField valor al modelo creado en el ejemplo "Definir un modelo" de esta guía. Este cast campo almacena una matriz de Actor modelos incrustados. El siguiente código define el Actor modelo y modifica el Movie modelo para incluir EmbeddedModelArrayField el:

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 modelos incrustados polimórficos

Puedes usar un PolymorphicEmbeddedModelField para representar un campo de documento de MongoDB que puede almacenar varios tipos de documentos incrustados. Cada documento incrustado se representa mediante una clase de modelo de Django MongoDB Backend.

Para crear un PolymorphicEmbeddedModelField, pase 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 PolymorphicEmbeddedModelField valor al modelo creado en el ejemplo "Definir un modelo" de esta guía. Este awards campo puede almacenar un modelo incrustado de tipo Oscars GoldenGlobeso. Cada modelo incrustado contiene información sobre todos los premios Óscar 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

Para aprender a consultar datos almacenados en un,PolymorphicEmbeddedModelField consulte Consultar valores de modelos incrustados polimórficos en la guía Especificar una consulta.

Almacenar datos de matrices de modelos incrustados polimórficos

Puedes usar un PolymorphicEmbeddedModelArrayField para representar un campo de documento de MongoDB que puede almacenar varios tipos de documentos incrustados. Este campo es similar al PolymorphicEmbeddedModelField, pero almacena una matriz de documentos incrustados en lugar de un solo documento. Cada documento incrustado en la matriz se representa mediante una clase del modelo de backend de Django MongoDB.

Para crear un PolymorphicEmbeddedModelArrayField, pase los siguientes argumentos al constructor de 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 PolymorphicEmbeddedModelArrayField valor al modelo creado en el ejemplo "Definir un modelo" de esta guía. Este awards campo puede almacenar una lista de modelos incrustados de tipo Oscar GoldenGlobeo. Cada modelo incrustado contiene información sobre un premio Óscar o Globo de Oro que haya 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 a consultar datos almacenados en un,PolymorphicEmbeddedModelArrayField consulte Consultar valores de matriz de modelos incrustados polimórficos en la guía Especificar una consulta.

Información Adicional

Para aprender a usar sus modelos para ejecutar operaciones de base de datos, consulte las guías Interactuar con datos.

Para obtener más información sobre los campos de Django, consulte la referencia del campo Modelo en la documentación de Django.

Volver

Cree índices

Datos geoespaciales del modelo