Crear modelos para representar colecciones

Campos de Django

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

Campos BSON de MongoDB

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

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:

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

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.

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

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.

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

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

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.

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

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.

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.

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

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

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