Especifica un query

API de consulta

El Django QuerySet La API proporciona métodos que permiten recuperar objetos de modelo. Para ejecutar una query de base de datos de MongoDB, llama a los métodos QuerySet en el administrador de tu modelo. La clase Manager gestiona las operaciones de la base de datos y permite interactuar con los datos de MongoDB haciendo referencia a modelos de Django. Por defecto, Django agrega un Manager llamado objects a cada clase de modelo.

Cuando asignas un QuerySet a una variable, Django MongoDB Backend no realiza la operación hasta que evalúas la variable. Después de evaluar el QuerySet, Django guarda los resultados de la consulta en la caché QuerySet. Las evaluaciones futuras de QuerySet utilizan los resultados almacenados en caché.

Datos de muestra

Los ejemplos de esta guía utilizan el modelo Movie, que representa la colección sample_mflix.movies de los conjuntos de datos de muestra de Atlas. El modelo Movie contiene un modelo Award incrustado como el valor de su campo awards. Estas clases de modelo tienen las siguientes definiciones:

from django.db import models
from django_mongodb_backend.models import EmbeddedModel
from django_mongodb_backend.fields import EmbeddedModelField, ArrayField
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)
    genres = ArrayField(models.CharField(max_length=100), null=True, blank=True)
    imdb = models.JSONField(null=True)
    class Meta:
        db_table = "movies"
        managed = False
    
    def __str__(self):
        return self.title

El modelo Movie incluye una clase interna Meta, que especifica los metadatos del modelo, y un método __str__(), que define la representación de cadena del modelo. Para obtener más información sobre estas características del modelo, consulte Defina un modelo en la guía Crear modelos.

python manage.py shell

from <your application name>.models import Movie, Award
from django.utils import timezone
from datetime import datetime

Recuperar todos los documentos

Para recuperar todos los documentos de una colección, llama al método all() en el administrador de tu modelo.

El siguiente ejemplo llama al método all() para recuperar todos los documentos en la colección sample_mflix.movies:

Movie.objects.all()

<QuerySet [<Movie: The Great Train Robbery>, <Movie: A Corner in Wheat>,
<Movie: Winsor McCay, the Famous Cartoonist of the N.Y. Herald and His Moving Comics>,
<Movie: Traffic in Souls>, <Movie: Gertie the Dinosaur>,
<Movie: In the Land of the Head Hunters>, <Movie: The Perils of Pauline>,
<Movie: The Italian>, <Movie: Regeneration>, <Movie: Civilization>,
'...(remaining elements truncated)...']>

Recuperar documentos coincidentes

Para consultar una colección en busca de documentos que coincidan con un conjunto de criterios, llama al método filter() en el administrador del modelo. Pasa un filtro de query al método filter() que especifique los criterios de tu query.

El siguiente ejemplo llama al método filter() para consultar la colección sample_mflix.movies en busca de documentos que tengan un valor runtime de 300:

Movie.objects.filter(runtime=300)

<QuerySet [<Movie: Wild Palms>, <Movie: Streets of Laredo>,
<Movie: The Way We Live Now>]>

Retrieve One Document

Para recuperar un documento de una colección, llame al método get() en el administrador de su modelo. Pase un filtro de consulta al método get() que especifique sus criterios de consulta.

El siguiente ejemplo llama al método get() para recuperar un documento que tiene un valor title de "Finding Nemo":

Movie.objects.get(title="Finding Nemo")

<Movie: Finding Nemo>

Excluir documentos coincidentes

Para hacer una query a una colección de documentos que no coincidan con tus criterios de búsqueda, llama al método exclude() en el administrador de tu modelo. Pasa los criterios de exclusión como argumento al método exclude().

El siguiente ejemplo llama al método exclude() para excluir de los resultados los documentos publicados antes del datetime(1980, 1, 1) (de enero del 1 de 1980):

Movie.objects.exclude(released__lt=timezone.make_aware(datetime(1980, 1, 1)))

<QuerySet [<Movie: The Iron Horse>, <Movie: Le grand jeu>,
<Movie: The Devil Is a Woman>, <Movie: Children in the Wind>,
<Movie: Too Much Johnson>, <Movie: Dots>, <Movie: The Blood of Jesus>,
<Movie: The Land>, <Movie: The Brothers and Sisters of the Toda Family>,
<Movie: Begone Dull Care>, '...(remaining elements truncated)...']>

Ejecutar queries sin formato a la base de datos

Si desea ejecutar consultas complejas que la API de consultas de Django no admite, puede usar el método raw_aggregate(). Este método le permite especificar los criterios de consulta en una canalización de agregación de MongoDB, que se pasa como argumento a raw_aggregate().

Para aprender a ejecutar consultas de base de datos sin procesar, consulte la guía Realizar consultas de base de datos sin procesar.

Utilizar búsquedas de coincidencia de texto

La siguiente tabla describe algunos de los tipos de búsqueda que puedes usar para ejecutar queries que incluyan criterios de coincidencia específicos para valores de texto:

Movie.objects.filter(plot__contains="coming-of-age")

<QuerySet [<Movie: Murmur of the Heart>, <Movie: Desert Bloom>,
<Movie: Girls Town>, <Movie: Get Real>, <Movie: Man of Steel>,
<Movie: The Holy Land>, <Movie: Secondhand Lions>, <Movie: How to Be Louise>,
<Movie: Mouth to Mouth>, <Movie: Che ne sarè di noi>, <Movie: Roll Bounce>,
'...(remaining elements truncated)...']>

Utiliza las búsquedas por comparación

En la siguiente tabla se describen algunos de los tipos de búsqueda que puede utilizar para ejecutar consultas que evalúen un valor de campo frente a un valor especificado:

Movie.objects.filter(runtime__lte=50)

<QuerySet [<Movie: The Great Train Robbery>, <Movie: A Corner in Wheat>,
<Movie: Winsor McCay, the Famous Cartoonist of the N.Y. Herald and His Moving Comics>,
<Movie: Gertie the Dinosaur>, <Movie: From Hand to Mouth>,
<Movie: High and Dizzy>, <Movie: One Week>, <Movie: Now or Never>,
'...(remaining elements truncated)...']>

Combinar búsquedas

Puede ejecutar queries que utilicen varios conjuntos de criterios de coincidencia de las siguientes maneras:

• Pasa varios filtros de query a tu método de query, separados por comas. Para ver un ejemplo, consulta Recuperar objetos en la documentación de Django.

• Encadena métodos de query juntos. Para obtener más información, consulte Encadenamiento de filtros en la documentación de Django.

• Usa objetos Q y separa cada objeto con un operador lógico. Para obtener más información, consulta Búsquedas complejas con objetos Q en la documentación de Django.

Movie.objects.filter(
    (Q(title__startswith="Funny") | Q(title__startswith="Laugh")) 
    & ~Q(genres__contains=["Comedy"])
)

<QuerySet [<Movie: Laugh, Clown, Laugh>, <Movie: Funny Games>]>

Ordenar resultados

Se puede proporcionar un orden de clasificación para los resultados de la consulta utilizando el método order_by(). Para especificar un orden ascendente basado en los valores de un campo determinado, pase el nombre del campo como argumento. Para especificar un orden descendente, pasa el nombre del campo precedido de un símbolo menos (-) como argumento.

Puedes pasar varios nombres de campos, separados por comas, al método order_by(). El backend de Django MongoDB ordena los resultados por cada campo en el orden suministrado.

Movie.objects.filter(title__startswith="Rocky").order_by("released")

<QuerySet [<Movie: Rocky>, <Movie: Rocky II>, <Movie: Rocky III>,
<Movie: Rocky IV>, <Movie: Rocky V>, <Movie: Rocky Marciano>,
<Movie: Rocky Balboa>]>

Omitir y Limitar Resultados

Puede especificar la cantidad de resultados que devuelve una consulta utilizando la sintaxis de segmentación de matrices de Python, como se muestra en el siguiente código:

Model.objects.filter(<query filter>)[<start>:<end>]

Reemplace los marcadores de posición <start> y <end> con valores enteros que representen el subconjunto de resultados que desea devolver. El valor inicial es exclusivo y el valor final es inclusivo.

Si omite el valor <start>, la consulta devuelve cada resultado, comenzando con la primera coincidencia, hasta que devuelve el número especificado por el valor <end>.

Si omite el valor <end>, la consulta devuelve cada resultado pero omite la cantidad de resultados iniciales especificados por <start>.

Movie.objects.filter(released=timezone.make_aware(datetime(2010, 7, 16)))[2:4]

<QuerySet [<Movie: Inception>, <Movie: Winter's Bone>]>

Recuperar el primer resultado

Para recuperar el primer resultado de una query que podría coincidir con múltiples resultados, encadena el método first() al método filter(). Pase un filtro de query al método filter() que especifique sus criterios de query.

El siguiente ejemplo llama a los métodos filter() y first() para query la colección sample_mflix.movies por el primer documento en el que el valor genres es ["Crime", "Comedy"]:

Movie.objects.filter(genres=["Crime", "Comedy"]).first()

<Movie: The Crew>

Consultar valores del modelo integrado

Puedes ejecutar operaciones sobre tu modelo que query campos de modelos embebidos. Para consultar estos campos, especifica el campo de tu modelo y cada nombre de campo embebido separado por dobles guiones bajos (__) hasta llegar al campo que deseas consultar, como se muestra en el siguiente código:

Model.objects.filter(<model field>__<embedded model field>=<value>)

También puedes usar búsquedas de campo para refinar tu query de modelos embebidos. Adicione su tipo de búsqueda después del campo del modelo incrustado que está consultando, precedido por double guiones bajos.

Movie.objects.filter(awards__wins__gt=150)

<QuerySet [<Movie: The Lord of the Rings: The Return of the King>,
<Movie: No Country for Old Men>, <Movie: Slumdog Millionaire>,
<Movie: Boyhood>, <Movie: The Social Network>, <Movie: Inception>,
<Movie: Gravity>, <Movie: Gravity>, <Movie: The Artist>,
<Movie: 12 Years a Slave>, <Movie: Birdman: Or (The Unexpected Virtue of Ignorance)>]>

query los valores del arreglo

Puede consultar datos almacenados en un valor ArrayField utilizando la sintaxis de consulta estándar. El backend de Django MongoDB ofrece tipos de búsqueda de campos adicionales para consultar valores ArrayField, que se describen en la siguiente tabla:

Movie.objects.filter(genres__overlap=["Adventure", "Family"])

<QuerySet [<Movie: The Poor Little Rich Girl>, <Movie: Robin Hood>,
<Movie: Peter Pan>, <Movie: The Thief of Bagdad>, <Movie: Clash of the Wolves>,
<Movie: Beau Geste>, <Movie: The Black Pirate>, <Movie: The Son of the Sheik>,
<Movie: Steamboat Willie>, <Movie: The Big Trail>, <Movie: The Champ>,
'...(remaining elements truncated)...']>

query valores en arreglo de modelo embebido

Puede ejecutar operaciones en su modelo que consulten campos de un arreglo de modelos integrados. Estas consultas utilizan la misma sintaxis que se describe en la sección Query de valores de modelos integrados:

Model.objects.filter(<model field>__<embedded model field>=<value>)

También puedes usar búsquedas de campo para refinar tu query de modelos embebidos. Agregue su tipo de búsqueda después del campo del modelo incrustado que está consultando, precedido de un double guión bajo. Sin embargo, solo puedes usar los siguientes tipos de búsqueda para consultar un campo incrustado:

• exact

• iexact

• in

• gt

• gte

• lt

• lte

Movie.objects.filter(cast__len__gt=5)

Movie.objects.filter(cast__0__last_name="Winslet")

Movie.objects.filter(cast__0_2__last_name="Winslet")

Query valores del modelo incrustado polimórfico

Para consultar los datos almacenados en un PolymorphicEmbeddedModelField valor, utilice la misma sintaxis descrita en la sección anterior "Consultar valores de modelos incrustados". Puede consultar campos compartidos entre los modelos incrustados o campos exclusivos de un modelo específico.

Movie.objects.filter(awards__wins=10)

Movie.objects.filter(awards__best_picture=True)

Consulta de valores de matriz de modelos incrustados polimórficos

Para consultar los datos almacenados en un valor PolymorphicEmbeddedModelArrayField, utiliza la misma sintaxis y los mismos operadores descritos en la sección Query valores de arreglos de modelos integrados. Puedes query campos que se comparten entre los modelos embebidos o campos que son únicos de un modelo específico.

Movie.objects.filter(awards__year__lt=2000)

query valores geoespaciales

Puedes usar búsquedas espaciales para consultar campos GeoDjango, que almacenan datos geoespaciales. El backend de MongoDB para Django admite las siguientes búsquedas espaciales:

• contains: Consultas de valores que contengan la geometría de búsqueda especificada, que debes especificar en un objeto Point

• disjoint:Consultas de valores que están espacialmente separados de la geometría de búsqueda o que no se intersecan con ella.

• distance_gt: Query para valores donde la distancia desde la geometría de búsqueda es mayor que el valor de distancia especificado

• distance_lte: Consultas para valores donde la distancia desde la geometría de búsqueda es menor o igual al valor de distancia especificado.

• dwithin:Consultas de valores donde la distancia desde la geometría de búsqueda está dentro del valor de distancia especificado

• intersects: Query de valores que intersecan espacialmente la geometría de búsqueda

• within:Consultas de valores que se encuentran espacialmente dentro de los límites de la geometría de búsqueda

Para aprender más sobre estas búsquedas, consulta Consultas espaciales en la documentación de Django.

from django.contrib.gis.geos import Polygon
manhattan_coords = [
    [-73.925492, 40.877410],
    [-73.910372, 40.872366],
    [-73.935127, 40.834020],
    [-73.929049, 40.798569],
    [-73.976485, 40.711432],
    [-74.015747, 40.701229],
    [-74.018859, 40.708367],
    [-74.008007, 40.754307],
    [-73.925492, 40.877410]
]
# Creates a polygon from the coordinates
search_area = Polygon(manhattan_coords)
Theater.objects.filter(location__geo__within=search_area)

<QuerySet [<Theater: 1908>, <Theater: 835>, <Theater: 1448>,
<Theater: 1028>, <Theater: 609>, <Theater: 1906>, <Theater: 1531>,
<Theater: 482>]>

Query JSON Values

Puedes query los datos almacenados en un valor JSONField utilizando la misma sintaxis que se muestra en la sección query valores de modelo incrustado. Encadena cada campo y nombre de campo anidado, separados por doble guion bajo (__), hasta llegar al campo que deseas query.

El siguiente ejemplo consulta el campo imdb valorado en JSONFieldpara los valores de su campo votes anidado que superan 900000:

Movie.objects.filter(imdb__votes__gt=900000)

<QuerySet [<Movie: La nao capitana>, <Movie: The Godfather>,
<Movie: This Is Spinal Tap>, <Movie: Forrest Gump>, <Movie: Pulp Fiction>,
<Movie: The Shawshank Redemption>, <Movie: Se7en>,
<Movie: The Lord of the Rings: The Fellowship of the Ring>,
<Movie: The Matrix>, <Movie: Fight Club>,
<Movie: The Lord of the Rings: The Return of the King>,
<Movie: The Lord of the Rings: The Two Towers>, <Movie: The Shawshank Redemption>,
<Movie: Landet som icke èr>, <Movie: The Dark Knight>,
<Movie: The Danish Girl>, <Movie: The Dark Knight Rises>, <Movie: Inception>,
<Movie: Catching the Sun>, <Movie: Scouts Guide to the Zombie Apocalypse>,
'...(remaining elements truncated)...']>

from django.db.models.fields.json import KT
Movie.objects.annotate(score=KT("imdb__rating")).all().order_by("-score")

<QuerySet [<Movie: No Tomorrow>, <Movie: The Deposit>, <Movie: Man Down>,
<Movie: Convenience>, <Movie: Scouts Guide to the Zombie Apocalypse>,
<Movie: Another World>, <Movie: The Danish Girl>, <Movie: Ad Inexplorata>,
<Movie: Landet som icke èr>, <Movie: The Ghost and the Whale>,
<Movie: Coming to Terms>, <Movie: La nao capitana>, <Movie: All Eyes and Ears>,
<Movie: Catching the Sun>, <Movie: Manhattan Romance>, <Movie: Anomalisa>,
<Movie: Outliving Emily>, <Movie: Mary Loss of Soul>,
<Movie: The Childhood of a Leader>, <Movie: Krot na more>,
'...(remaining elements truncated)...']>

Consulta los valores de la clave primaria

Puedes utilizar el atajo de búsqueda pk para query los valores de llave primaria, que MongoDB almacenar como valores ObjectId.

El siguiente ejemplo query la colección sample_mflix.movies en busca de un documento cuya llave primaria es ObjectId("573a1394f29313caabce0d37"):

from bson import ObjectId
Movie.objects.get(pk=ObjectId("573a1394f29313caabce0d37"))

// Your ObjectId values might differ
<Movie: Vertigo>

El modelo Movie, que representa la colección sample_mflix.movies, utiliza el campo id como llave primaria. El siguiente ejemplo construye la misma consulta que el código anterior utilizando el campo id:

from bson import ObjectId
Movie.objects.get(id=ObjectId("573a1394f29313caabce0d37"))