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 campos BSON admitidos y sus equivalentes de Django MongoDB Backend que puede usar en sus 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_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 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 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 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 modelos incrustados polimórficos

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, 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.

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

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

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

Restricciones de campo incrustadas

Para establecer una restricción única en los subcampos de los campos del modelo incrustado, asigne la opción Meta.constraints a un objeto EmbeddedFieldUniqueConstraint. Pase los siguientes argumentos al constructor EmbeddedFieldUniqueConstraint() en cualquier orden:

• name: El nombre de tu restricción.

• fieldssubset: Uno o varios subcampos que deben almacenar valores únicos. Utiliza la notación de puntos para hacer referencia a los nombres de subcampos.

El siguiente ejemplo establece una restricción única en el Award campo del modelo text incrustado, definido en el ejemplo Almacenar datos del modelo incrustado, modificando la Movie Meta clase del modelo:

class Meta:
    db_table = "movies"
    managed = False
    constraints = [
        EmbeddedFieldUniqueConstraint(
           name="unique_award_details",
           fields=["awards.text"],
        )
    ]