Operadores de queries

Criar consultas no PyODMongo é simples e intuitivo. Ele simplifica o processo de construção de consultas no MongoDB, fornecendo uma abordagem pythônica e direta.

No PyODMongo, uma consulta serve como um atributo essencial dos métodos find_many, find_one, delete e save, que estão disponíveis através das classes DbEngine e AsyncDbEngine. Esses métodos permitem que você recupere dados do seu banco de dados MongoDB com facilidade, combinando a simplicidade do Python com as robustas capacidades de consulta do MongoDB.

Operadores

Equal (Igual)

O operador Equal é usado para combinar documentos onde o valor de um campo é igual ao valor especificado. É um operador básico de comparação no MongoDB e PyODMongo.

Magic methodPyODMongo queries

from pyodmongo import DbEngine, DbModel
from typing import ClassVar

engine = DbEngine(mongo_uri="mongodb://localhost:27017", db_name="my_db")


class Product(DbModel):
    name: str
    price: float
    is_available: bool
    _collection: ClassVar = "products"


query = Product.name == "Box"
box: Product = engine.find_one(Model=Product, query=query)

from pyodmongo import DbEngine, DbModel
from typing import ClassVar
from pyodmongo.queries import eq

engine = DbEngine(mongo_uri="mongodb://localhost:27017", db_name="my_db")


class Product(DbModel):
    name: str
    price: float
    is_available: bool
    _collection: ClassVar = "products"


query = eq(Product.name, "Box")
box: Product = engine.find_one(Model=Product, query=query)

Filtro equivalente no MongoDB

{name: {$eq: "Box"}}

Greater than (Maior que)

O operador Greater than é usado para combinar documentos onde o valor de um campo é maior que o valor especificado. Ele ajuda a filtrar registros que excedem um determinado limite.

Magic methodPyODMongo queries

from pyodmongo import DbEngine, DbModel
from typing import ClassVar

engine = DbEngine(mongo_uri="mongodb://localhost:27017", db_name="my_db")


class Product(DbModel):
    name: str
    price: float
    is_available: bool
    _collection: ClassVar = "products"


query = Product.price > 10
box: Product = engine.find_one(Model=Product, query=query)

from pyodmongo import DbEngine, DbModel
from typing import ClassVar
from pyodmongo.queries import gt

engine = DbEngine(mongo_uri="mongodb://localhost:27017", db_name="my_db")


class Product(DbModel):
    name: str
    price: float
    is_available: bool
    _collection: ClassVar = "products"


query = gt(Product.price, 10)
box: Product = engine.find_one(Model=Product, query=query)

Filtro equivalente no MongoDB

{price: {$gt: 10}}

Greater than equal (Maior ou igual que)

O operador Greater than equal combina documentos onde o valor de um campo é maior ou igual ao valor especificado. Isso é útil para consultas de intervalo que incluem o valor limite.

Magic methodPyODMongo queries

from pyodmongo import DbEngine, DbModel
from typing import ClassVar

engine = DbEngine(mongo_uri="mongodb://localhost:27017", db_name="my_db")


class Product(DbModel):
    name: str
    price: float
    is_available: bool
    _collection: ClassVar = "products"


query = Product.price >= 10
box: Product = engine.find_one(Model=Product, query=query)

from pyodmongo import DbEngine, DbModel
from typing import ClassVar
from pyodmongo.queries import gte

engine = DbEngine(mongo_uri="mongodb://localhost:27017", db_name="my_db")


class Product(DbModel):
    name: str
    price: float
    is_available: bool
    _collection: ClassVar = "products"


query = gte(Product.price, 10)
box: Product = engine.find_one(Model=Product, query=query)

Filtro equivalente no MongoDB

{price: {$gte: 10}}

In (Em)

O operador In permite especificar um array de valores possíveis para um campo. Ele combina documentos onde o valor do campo está no array especificado.

PyODMongo queries

from pyodmongo import DbEngine, DbModel
from typing import ClassVar
from pyodmongo.queries import in_

engine = DbEngine(mongo_uri="mongodb://localhost:27017", db_name="my_db")


class Product(DbModel):
    name: str
    price: float
    is_available: bool
    _collection: ClassVar = "products"


query = in_(Product.name, ["Ball", "Box", "Toy"])
box: Product = engine.find_one(Model=Product, query=query)

Filtro equivalente no MongoDB

{name: {$in: ["Ball", "Box", "Toy"]}}

Lower than (Menor que)

O operador Lower than combina documentos onde o valor de um campo é menor que o valor especificado. Isso é usado para filtrar registros abaixo de um determinado limite.

Magic methodPyODMongo queries

from pyodmongo import DbEngine, DbModel
from typing import ClassVar

engine = DbEngine(mongo_uri="mongodb://localhost:27017", db_name="my_db")


class Product(DbModel):
    name: str
    price: float
    is_available: bool
    _collection: ClassVar = "products"


query = Product.price < 10
box: Product = engine.find_one(Model=Product, query=query)

from pyodmongo import DbEngine, DbModel
from typing import ClassVar
from pyodmongo.queries import lt

engine = DbEngine(mongo_uri="mongodb://localhost:27017", db_name="my_db")


class Product(DbModel):
    name: str
    price: float
    is_available: bool
    _collection: ClassVar = "products"


query = lt(Product.price, 10)
box: Product = engine.find_one(Model=Product, query=query)

Filtro equivalente no MongoDB

{price: {$lt: 10}}

Lower than equal (Menor ou igual que)

O operador Lower than equal combina documentos onde o valor de um campo é menor ou igual ao valor especificado. Isso inclui o valor limite nos resultados.

Magic methodPyODMongo queries

from pyodmongo import DbEngine, DbModel
from typing import ClassVar

engine = DbEngine(mongo_uri="mongodb://localhost:27017", db_name="my_db")


class Product(DbModel):
    name: str
    price: float
    is_available: bool
    _collection: ClassVar = "products"


query = Product.price <= 10
box: Product = engine.find_one(Model=Product, query=query)

from pyodmongo import DbEngine, DbModel
from typing import ClassVar
from pyodmongo.queries import lte

engine = DbEngine(mongo_uri="mongodb://localhost:27017", db_name="my_db")


class Product(DbModel):
    name: str
    price: float
    is_available: bool
    _collection: ClassVar = "products"


query = lte(Product.price, 10)
box: Product = engine.find_one(Model=Product, query=query)

Filtro equivalente no MongoDB

{price: {$lte: 10}}

Not equal (Diferente)

O operador Not equal combina documentos onde o valor de um campo não é igual ao valor especificado. Ele é usado para excluir documentos com um valor específico.

Magic methodPyODMongo queries

from pyodmongo import DbEngine, DbModel
from typing import ClassVar

engine = DbEngine(mongo_uri="mongodb://localhost:27017", db_name="my_db")


class Product(DbModel):
    name: str
    price: float
    is_available: bool
    _collection: ClassVar = "products"


query = Product.name != "Box"
box: Product = engine.find_one(Model=Product, query=query)

from pyodmongo import DbEngine, DbModel
from typing import ClassVar
from pyodmongo.queries import ne

engine = DbEngine(mongo_uri="mongodb://localhost:27017", db_name="my_db")


class Product(DbModel):
    name: str
    price: float
    is_available: bool
    _collection: ClassVar = "products"


query = ne(Product.name, "Box")
box: Product = engine.find_one(Model=Product, query=query)

Filtro equivalente no MongoDB

{name: {$ne: "Box"}}

Not in (Não em)

O operador Not in permite especificar um array de valores aos quais o campo não deve ser igual. Ele combina documentos onde o valor do campo não está no array especificado.

PyODMongo queries

from pyodmongo import DbEngine, DbModel
from typing import ClassVar
from pyodmongo.queries import nin

engine = DbEngine(mongo_uri="mongodb://localhost:27017", db_name="my_db")


class Product(DbModel):
    name: str
    price: float
    is_available: bool
    _collection: ClassVar = "products"


query = nin(Product.name, ["Ball", "Box", "Toy"])
box: Product = engine.find_one(Model=Product, query=query)

Filtro equivalente no MongoDB

{name: {$nin: ["Ball", "Box", "Toy"]}}

And (E)

O operador And é usado para unir várias cláusulas de consulta com um E lógico. Ele garante que todas as condições especificadas sejam verdadeiras para que um documento seja incluído no conjunto de resultados.

Magic methodPyODMongo queries

from pyodmongo import DbEngine, DbModel
from typing import ClassVar

engine = DbEngine(mongo_uri="mongodb://localhost:27017", db_name="my_db")


class Product(DbModel):
    name: str
    price: float
    is_available: bool
    _collection: ClassVar = "products"


query = (Product.price > 10) & (Product.price <= 50)
box: Product = engine.find_one(Model=Product, query=query)

from pyodmongo import DbEngine, DbModel
from typing import ClassVar
from pyodmongo.queries import and_, gt, lte

engine = DbEngine(mongo_uri="mongodb://localhost:27017", db_name="my_db")


class Product(DbModel):
    name: str
    price: float
    is_available: bool
    _collection: ClassVar = "products"


query = and_(gt(Product.price, 10), lte(Product.price, 50))
box: Product = engine.find_one(Model=Product, query=query)

Filtro equivalente no MongoDB

{$and: [{price: {$gt: 10}}, {price: {$lte: 50}}]}

Or (Ou)

O operador Or une cláusulas de consulta com um OU lógico, combinando documentos que satisfazem pelo menos uma das condições especificadas.

Magic methodPyODMongo queries

from pyodmongo import DbEngine, DbModel
from typing import ClassVar

engine = DbEngine(mongo_uri="mongodb://localhost:27017", db_name="my_db")


class Product(DbModel):
    name: str
    price: float
    is_available: bool
    _collection: ClassVar = "products"


query = (Product.name == "Box") | (Product.price == 100)
box: Product = engine.find_one(Model=Product, query=query)

from pyodmongo import DbEngine, DbModel
from typing import ClassVar
from pyodmongo.queries import or_, eq

engine = DbEngine(mongo_uri="mongodb://localhost:27017", db_name="my_db")


class Product(DbModel):
    name: str
    price: float
    is_available: bool
    _collection: ClassVar = "products"


query = or_(eq(Product.name, "Box"), eq(Product.price, 100))
box: Product = engine.find_one(Model=Product, query=query)

Filtro equivalente no MongoDB

{$or: [{name: {$eq: "Box"}}, {price: {$eq: 100}}]}

Nor

O operador Nor une cláusulas de consulta com um NOR lógico, combinando documentos que não atendem a nenhuma das condições especificadas.

PyODMongo queries

from pyodmongo import DbEngine, DbModel
from typing import ClassVar
from pyodmongo.queries import nor, eq

engine = DbEngine(mongo_uri="mongodb://localhost:27017", db_name="my_db")


class Product(DbModel):
    name: str
    price: float
    is_available: bool
    _collection: ClassVar = "products"


query = nor(eq(Product.name, "Box"), eq(Product.price, 100))
box: Product = engine.find_one(Model=Product, query=query)

Filtro equivalente no MongoDB

{$nor: [{name: {$eq: "Box"}}, {price: {$eq: 100}}]}

Elem match

O operador Elem match é usado para combinar documentos que contêm um campo de array com pelo menos um elemento que corresponde a todos os critérios especificados.

PyODMongo queries

from pyodmongo import DbEngine, MainBaseModel, DbModel
from typing import ClassVar
from pyodmongo.queries import elem_match

engine = DbEngine(mongo_uri="mongodb://localhost:27017", db_name="my_db")


class Product(MainBaseModel):
    name: str
    price: float
    is_available: bool


class Order(DbModel):
    code: str
    products: list[Product]
    _collection: ClassVar = "orders"


query = elem_match(Product.name == "Box", Product.price == 50, field=Order.products)
box: Product = engine.find_one(Model=Product, query=query)

Filtro equivalente no MongoDB

{$products: {$elemMatch: {name: "Box", price: 50}}}

Sort

O operador Sort organiza os resultados de uma consulta em uma ordem especificada. Ele é útil para organizar os dados em ordem ascendente ou descendente com base em um campo particular.

PyODMongo queries

from pyodmongo import DbEngine, DbModel
from typing import ClassVar
from pyodmongo.queries import sort

engine = DbEngine(mongo_uri="mongodb://localhost:27017", db_name="my_db")


class Product(DbModel):
    name: str
    price: float
    is_available: bool
    _collection: ClassVar = "products"


query = Product.price >= 10
my_sort = sort((Product.name, 1), (Product.price, -1))
box: Product = engine.find_one(Model=Product, query=query, sort=my_sort)

Filtro equivalente no MongoDB

{name: 1, price: -1}