Construtores de filtros

Visão geral

Neste guia, você pode aprender como usar construtores para especificar filtros para suas queries no driver MongoDB Kotlin.

Os construtores são classes fornecidas pelo driver Kotlin do MongoDB que o ajudam a construir objetosBSON do . Para saber mais, consulte nosso guia sobre construtores.

Filtros são operações usadas para limitar os resultados de uma query com base em condições especificadas. Os filtros são uma ferramenta útil para localizar informações que correspondam às condições de pesquisa em uma collection.

Você pode usar filtros nos seguintes locais:

• Como um parâmetro para o método find()

• Em um estágio de correspondência de um aggregation pipeline

• Como um parâmetro para o método deleteOne() ou deleteMany()

• Como um parâmetro para o método updateOne() ou updateMany()

Alguns exemplos de resultados de queries com filtros são:

• Itens que custam mais de US$ 0, mas menos de US$ 25.

• Alimento sem Gluten e com menos de 500 calorias.

• Uma revisão crítica de gastronomia que menciona "picante".

Este guia mostra como usar construtores com exemplos dos seguintes tipos de operadores:

• Comparação

• Lógica

• arrays

• Elementos

• Avaliação

• Bit a bit

• Geoespacial

A classe Filters fornece métodos de fábrica estáticos para todos os operadores de query do MongoDB. Cada método retorna uma instância do tipo BSON , que você pode passar para qualquer método que espera um filtro de query.

import com.mongodb.client.model.Filters.*

A maioria dos exemplos Filter neste guia usam a seguinte coleção de amostras paints:

{ "_id": 1, "color": "red", "qty": 5, "vendor": ["A"] }
{ "_id": 2, "color": "purple", "qty": 10, "vendor": ["C", "D"] }
{ "_id": 3, "color": "blue", "qty": 8, "vendor": ["B", "A"] }
{ "_id": 4, "color": "white", "qty": 6, "vendor": ["D"] }
{ "_id": 5, "color": "yellow", "qty": 11, "vendor": ["A", "B"] }
{ "_id": 6, "color": "pink", "qty": 5, "vendor": ["C"] }
{ "_id": 7, "color": "green", "qty": 8,"vendor": ["B", "C"] }
{ "_id": 8, "color": "orange", "qty": 7, "vendor": ["A", "D"] }

Esses documento na collection paints são modelados pela seguinte classe de dados para uso com o driver Kotlin:

data class PaintOrder(
    @BsonId val id: Int,
    val qty: Int,
    val color: String,
    val vendors: List<String> = mutableListOf()
)

Comparação

Os filtros de comparação incluem todos os operadores que comparam o valor em um documento com um valor especificado.

Os métodos do operador de comparação Filters incluem:

O exemplo a seguir cria um filtro que corresponde a todos os documentos onde o valor do campo qty é igual a "5" na collection paints:

val equalComparison = Filters.eq(PaintOrder::qty.name, 5)
val resultsFlow = collection.find(equalComparison)
resultsFlow.collect { println(it) }

PaintOrder(id=1, qty=5, color=red, vendors=[A])
PaintOrder(id=6, qty=5, color=pink, vendors=[C])

O exemplo a seguir cria um filtro que corresponde a todos os documentos onde o valor do campo qty é maior ou igual a "10" na collection paints:

val gteComparison = Filters.gte(PaintOrder::qty.name, 10)
val resultsFlow = collection.find(gteComparison)
resultsFlow.collect { println(it) }

PaintOrder(id=2, qty=10, color=purple, vendors=[C, D])
PaintOrder(id=5, qty=11, color=yellow, vendors=[A, B])

O exemplo seguinte cria um filtro que corresponde a todos os documentos na collection paints porque o predicado está vazio:

val emptyComparison = Filters.empty()
val resultsFlow = collection.find(emptyComparison)
resultsFlow.collect { println(it) }

PaintOrder(id=1, qty=5, color=red, vendors=[A])
PaintOrder(id=2, qty=10, color=purple, vendors=[C, D])
PaintOrder(id=3, qty=8, color=blue, vendors=[B, A])
PaintOrder(id=4, qty=6, color=white, vendors=[D])
PaintOrder(id=5, qty=11, color=yellow, vendors=[A, B])
PaintOrder(id=6, qty=5, color=pink, vendors=[C])
PaintOrder(id=7, qty=8, color=green, vendors=[B, C])
PaintOrder(id=8, qty=7, color=orange, vendors=[A, D])

Lógica

Os operadores lógicos executam operações lógicas com base nas condições do método especificado.

Os métodos do operador lógico Filters incluem:

O exemplo a seguir cria um filtro que corresponde a documentos em que o valor do campo qty é maior que "8" ou o valor do campo color é igual a "pink" na collection paints:

val orComparison = Filters.or(
    Filters.gt(PaintOrder::qty.name, 8),
    Filters.eq(PaintOrder::color.name, "pink")
)
val resultsFlow = collection.find(orComparison)
resultsFlow.collect { println(it) }

PaintOrder(id=2, qty=10, color=purple, vendors=[C, D])
PaintOrder(id=5, qty=11, color=yellow, vendors=[A, B])
PaintOrder(id=6, qty=5, color=pink, vendors=[C])

arrays

Os operadores de array avaliam o campo do array em um documento.

Os métodos do operador de array Filters incluem:

O exemplo a seguir corresponde a documentos com uma array vendors contendo "A" e "D" na collection paints:

val search = listOf("A", "D")
val allComparison = Filters.all(PaintOrder::vendors.name, search)
val resultsFlow = collection.find(allComparison)
resultsFlow.collect { println(it) }

PaintOrder(id=8, qty=7, color=orange, vendors=[A, D])

Elementos

Os operadores de elementos avaliam a natureza de um campo especificado.

Os métodos do operador de elementos Filters incluem:

O exemplo a seguir corresponde a documentos que têm um campo qty e seu valor não é igual a "5" ou "8" na collection paints:

val existsComparison = Filters.and(Filters.exists(PaintOrder::qty.name), Filters.nin("qty", 5, 8))
val resultsFlow = collection.find(existsComparison)
resultsFlow.collect { println(it) }

PaintOrder(id=2, qty=10, color=purple, vendors=[C, D])
PaintOrder(id=4, qty=6, color=white, vendors=[D])
PaintOrder(id=5, qty=11, color=yellow, vendors=[A, B])
PaintOrder(id=8, qty=7, color=orange, vendors=[A, D])

Avaliação

Os operadores de avaliação analisam o valor de qualquer campo em um documento.

Os métodos do operador de avaliação do Filters incluem:

O exemplo a seguir corresponde a documentos que têm um campo color que começa com a letra "p" na collection paints:

val regexComparison = Filters.regex(PaintOrder::color.name, "^p")
val resultsFlow = collection.find(regexComparison)
resultsFlow.collect { println(it) }

PaintOrder(id=2, qty=10, color=purple, vendors=[C, D])
PaintOrder(id=6, qty=5, color=pink, vendors=[C])

Bit a bit

Os operadores de bitwise convertem um número em seu valor binário para avaliar seus bits.

Os métodos do operador bitwise Filters incluem:

O exemplo a seguir combina documentos que têm um campo decimalValue com bits definidos nas posições da máscara de bits correspondente "34" (ou seja, "00100010") nesta collection binary_numbers :

{ "_id": 9, "decimalValue": 54, "binaryValue": "00110110" }
{ "_id": 10, "decimalValue": 20, "binaryValue": "00010100" }
{ "_id": 11, "decimalValue": 68, "binaryValue": "1000100" }
{ "_id": 12, "decimalValue": 102, "binaryValue": "01100110" }

data class BinaryNumber(
    @BsonId val id: Int,
    val decimalValue: Int,
    val binaryValue: String
)
val binaryCollection = database.getCollection<BinaryNumber>("binary_numbers")
val bitmask = 34.toLong() // 00100010 in binary
val bitsComparison = Filters.bitsAllSet(BinaryNumber::decimalValue.name, bitmask)
val resultsFlow = binaryCollection.find(bitsComparison)
resultsFlow.collect { println(it) }

BinaryNumber(id=1, decimalValue=54, binaryValue=00110110)
BinaryNumber(id=4, decimalValue=102, binaryValue=01100110)

Geoespacial

Os operadores geoespaciais avaliam uma coordenada especificada e sua relação com uma forma ou localização.

Os métodos do operador geoespacial Filters incluem:

O exemplo a seguir cria um filtro que corresponde a documentos nos quais o campo point contém uma geometria GeoJSON que se enquadra no polígono fornecido nesta coleção stores :

{ "_id": 13, "coordinates": { "type": "Point", "coordinates": [2.0, 2.0] } }
{ "_id": 14, "coordinates": { "type": "Point", "coordinates": [5.0, 6.0] } }
{ "_id": 15, "coordinates": { "type": "Point", "coordinates": [1.0, 3.0] } }
{ "_id": 16, "coordinates": { "type": "Point", "coordinates": [4.0, 7.0] } }

data class Store(
    @BsonId val id: Int,
    val name: String,
    val coordinates: Point
)
val collection = database.getCollection<Store>("stores")
val square = Polygon(listOf(
    Position(0.0, 0.0),
    Position(4.0, 0.0),
    Position(4.0, 4.0),
    Position(0.0, 4.0),
    Position(0.0, 0.0)))
val geoWithinComparison = Filters.geoWithin(Store::coordinates.name, square)
val resultsFlow = collection.find(geoWithinComparison)
resultsFlow.collect { println(it) }

Store(id=13, name=Store 13, coordinates=Point{coordinate=Position{values=[2.0, 2.0]}})
Store(id=15, name=Store 15, coordinates=Point{coordinate=Position{values=[1.0, 3.0]}})