Para agentes de IA: um índice de documentação está disponível em https://www.mongodb.com/pt-br/docs/llms.txt — as versões de markdown de todas as páginas estão disponíveis anexando .md a qualquer caminho de URL.
Menu Docs
Página inicial do Docs
/ /
Interaja com dados
Página inicial do Docs
/ /
Backend do Django MongoDB
/
Interaja com dados
Página inicial do Docs
/
Bibliotecas do cliente
/
Python
/
Backend do Django MongoDB
/
Interaja com dados

Executar queries de banco de dados bruto

Visão geral

Neste guia, você pode aprender como usar o Django MongoDB Backend para executar queries brutas em seu banco de dados MongoDB . As queries brutas permitem consultar o banco de dados usando a sintaxe de pipeline de agregação do MongoDB em vez dos métodos do Django. Você também pode executar queries diretamente no seu objeto MongoClient para acesso expandido aos seus dados do MongoDB .

API de Consulta

A API do Django QuerySet fornece um método raw(), que permite executar queries SQL bruto em bancos de dados relacionais. No entanto, o Backend Django MongoDB não suporta o método raw(). Em vez disso, o ODM fornece o método raw_aggregate(), que você pode usar para enviar instruções ao banco de dados em estágios de pipeline.

Observação

Django provides a QuerySet.aggregate() method, which differs from the QuerySet.raw_aggregate() method. You can use aggregate() to retrieve values by aggregating a collection of model objects. To learn more about the aggregate() method, see aggregate in the Django documentation.

Você pode executar queries de banco de dados chamando métodos QuerySet no Manager do seu modelo. A classe Manager lida com operações de banco de dados e permite que você interaja com os dados do MongoDB fazendo referência a modelos do Django. Por padrão, o Django adiciona um Manager denominado objects a cada classe de modelo. Este Manager padrão não suporta o método raw_aggregate(). Para usar esse método específico do MongoDB, defina o campo objects do seu modelo como um gerenciador personalizado chamado MongoManager.

Dados de amostra

The examples in this guide use the Movie and Theater models, which represent collections in the sample_mflix database from the Atlas sample datasets. These models explicitly set the objects field to use a custom MongoManager, rather than Django's default Manager class. This guide also uses a Location embedded model to represent the Theater model's location field. The model classes have the following definitions:

from django.db import models
from django.contrib.gis.db import models
from django_mongodb_backend.fields import ArrayField, EmbeddedModelField
from django_mongodb_backend.models import EmbeddedModel
from django_mongodb_backend.managers import MongoManager
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), null=True, blank=True)
    objects = MongoManager()
    class Meta:
        db_table = "movies"
        managed = False
    def __str__(self):
        return self.title
class Location(EmbeddedModel):
    address = models.JSONField(null=True)
    geo = models.PointField()
class Theater(models.Model):
    theaterId = models.IntegerField(default=0)
    location = EmbeddedModelField(Location, null=True, blank=True)
    class Meta:
        db_table = "theaters"
        managed = False
    
    def __str__(self):
        return self.theaterId

Os modelos Movie e Theater incluem uma classe Meta interna, que especifica os metadados do modelo, e um método __str__(), que define a representação de string do modelo. Para saber mais sobre esses recursos de modelo, consulte Definir um modelo no guia Criar modelos.

Exemplos de código de execução

Você pode usar o shell interativo do Python para executar os exemplos de código. Para entrar na shell, execute o seguinte comando no diretório raiz do seu projeto:

python manage.py shell

Depois de inserir o shell do Python, certifique-se de importar os seguintes modelos e módulos:

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

Para saber como criar um aplicação Django que usa o Movie modelo e o shell interativo do Python para interagir com documentos do MongoDB , acesse o tutorial Introdução ao Django MongoDB Backend.

Executar queries brutas

Para executar uma query de banco de dados bruto, passe um pipeline de agregação para o método raw_aggregate(). Os pipelines de agregação contêm um ou mais estágios que fornecem instruções sobre como processar documentos. Depois de chamar o método raw_aggregate(), o Django MongoDB Backend passa seu pipeline para o método pymongo.collection.Collection.aggregate() e retorna os resultados da query como objetos de modelo.

Dica

Para saber mais sobre a construção de agregação pipelines, consulte Aggregation Pipeline no manual do MongoDB Server .

Esta seção mostra como usar o método raw_aggregate() para executar as seguintes tarefas:

Filtrar e projetar campos de documento

Este exemplo executa uma query do banco de dados bruto chamando o método raw_aggregate() no MongoManager do seu modelo Movie, que query a collection sample_mflix.movies. O código passa os seguintes estágios do pipeline de agregação para raw_aggregate():

  • $match: filtros para documentos que têm um valor de campo title de "The Parent Trap"

  • $project: inclui os campos title e released dos objetos de modelo retornados

movies = Movie.objects.raw_aggregate([
    {"$match": {"title": "The Parent Trap"}},
    {"$project": {
        "title": 1,
        "released": 1
    }
}])
for m in movies:
    print(f"Plot of {m.title}, released on {m.released}: {m.plot}\n")

Observação

O método raw_aggregate() retorna instâncias de modelo adiadas, o que significa que você pode carregar campos omitidos pelo estágio $project sob demanda. No exemplo anterior, a query recupera os campos title e released. A instrução print executa uma query separada para recuperar o campo plot.

Executar uma query de pesquisa do MongoDB

Dica

Você também pode executar querys de pesquisa do MongoDB usando as expressões de pesquisa do backend do MongoDB. Para saber mais, consulte o Executar uma query de pesquisa do MongoDB guia.

Você pode executar queries de pesquisa do MongoDB Search em seu banco de dados para realizar pesquisas de texto refinadas. Essas queries oferecem funcionalidade de pesquisa avançada, como correspondência de frases de texto, pontuação de resultados por relevância e realce de correspondências.

Para especificar uma query de pesquisa do MongoDB Search, crie um índice de pesquisa que abranja os campos que você deseja executar a query. Em seguida, passe um estágio $search ou $searchMeta em um parâmetro do pipeline de agregação para o método raw_aggregate().

Dica

Para aprender como criar índices de pesquisa, consulte Índices de pesquisa no guia Criar índices.

Este exemplo executa uma query de pesquisa do MongoDB Search passando o estágio de pipeline $search para o método raw_aggregate(). O código executa as seguintes ações:

  • Especifica o índice de pesquisa que cobre o campo plot

  • Queries de documentos cujos valores plot contêm a string "whirlwind romance" com não mais de 3 palavras entre eles

  • Retorna partes dos valores da string plot que correspondem à query e aos metadados que indicam onde as correspondências ocorreram

  • Inclui o campo title e o highlight, ou texto correspondente, de cada resultado

movies = Movie.objects.raw_aggregate([
    {
        "$search": {
            "index": "<search-index-name>",
            "phrase": {
                "path": "plot",
                "query": "whirlwind romance",
                "slop": 3
            },
            "highlight": {
                "path": "plot"
            }
        }
    },
    {
        "$project": {
            "title": 1,
            "highlight": {"$meta": "searchHighlights"}
        }
    }
])
for m in movies:
    print(f"Title: {m.title}, text match details: {m.highlight}\n")

Importante

Ao executar o exemplo anterior, certifique-se de substituir o espaço reservado <search-index-name> pelo nome do índice de pesquisa que cobre o campo plot.

Executar query de dados geoespaciais

Dica

Pesquisas espaciais

Começando no Django MongoDB Backend v6.0.1, você pode usar algumas pesquisas espaciais da API QuerySet do GIS. Para aprender mais, consulte Query Valores geoespacial no guia Especificar uma Query.

Você pode utilizar o método raw_aggregate() para executar queries em campos contendo dados geoespaciais. Os dados geoespaciais representam uma localização geográfica na superfície da Terra ou em um plano euclidiano.

Para executar uma query geoespacial, crie um índice 2d ou 2dsphere em campos contendo dados geoespaciais. Em seguida, passe um dos seguintes operadores de query em um parâmetro do pipeline de agregação para o método raw_aggregate():

  • $near

  • $geoWithin

  • $nearSphere

  • $geoIntersects

Dica

O Django MongoDB Backend cria automaticamente 2dsphere índices em GeoDjango campos, incluindo o PointField definido no modelo de amostra deste guia Location. Para saber como definir esses campos, consulte o guia Dados geoespaciais do modelo.

Este exemplo executa uma query geoespacial passando os estágios de pipeline $match e $geoWithin para o método raw_aggregate(). O código executa as seguintes ações:

  • Especifica uma lista de coordenadas que representam os limites de Chigogo

  • Queries de documentos em que o campo location.geo armazena um local dentro da área de Chigogo

  • Recupera e imprime os valores theaterId de cada cinema em Chigago

chicago_bounds = {
    "type": "Polygon",
    "coordinates": [[
        [-87.851, 41.976],
        [-87.851, 41.653],
        [-87.651, 41.653],
        [-87.651, 41.976],
        [-87.851, 41.976] 
    ]]
}
theaters = Theater.objects.raw_aggregate([
    {
        "$match": {
            "location.geo": {
                "$geoWithin": {
                    "$geometry": chicago_bounds
                }
            }
        }
    },
    {
        "$project": {
            "theaterId": 1
        }
    }
])
for t in theaters:
    print(f"Theater ID: {t.theaterId}")

Operações do MongoClient

Se desejar executar operações de banco de dados que nem a API QuerySet nem o método raw_aggregate() fornecem, você poderá operar diretamente em seu MongoClient. Ao trabalhar com o MongoClient, você pode acessar as operações do banco de dados do driver PyMongo. Use a seguinte sintaxe para expor o MongoClient:

from django.db import connections
client = connections["<DATABASES key>"].database.client

Substitua o espaço reservado "<DATABASES key>" pela chave em seu dicionário DATABASES que corresponde ao seu banco de dados de destino. Para utilizar seu banco de dados padrão, substitua o espaço reservado por "default".

Dica

Para saber como usar o PyMongo para interagir com dados do MongoDB , consulte a documentação do PyMongo.

Informações adicionais

Para ver mais exemplos que usam o método raw_aggregate(), consulte Referência da API QuerySet na documentação da API de backend do Django MongoDB.

Para saber mais sobre como executar operações de agregação , consulte Operações de agregação no manual do MongoDB Server .

Para aprender mais sobre o MongoDB pesquisa, consulte MongoDB pesquisa na documentação do Atlas.

To learn more about running geospatial queries, see Geospatial Queries in the MongoDB Server manual.

Voltar
Especificar uma query
Próximo
MongoDB Search
Avalie esta página

Nesta página