Construtores de filtros

Visão geral

Neste guia, você pode aprender como usar construtores para especificar filtros para suas queries no driver Java Reactive Streams.

Builders são classes fornecidas pelo driver Java Reactive Streams que o ajudam a construir objetos BSON. Para saber mais, consulte o guia do construtor.

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

• Alimentos que são sem Gluten e menos de 500 calorias

• Resenhas de críticos de gastronomia que mencionam "picante"

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

• Comparação
• Lógica
• arrays
• Elementos
• Avaliação
• Bitwise
• Geoespacial

A Filters classe 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 static com.mongodb.client.model.Filters.*;

Dados de amostra

Os exemplos deste guia usam as seguintes collections de amostras:

Collection: paint_purchases

{ "_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"] }

Collection: binary_numbers

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

Collection: geo_points

{ "_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] } }

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 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 paint_purchases:

Bson equalComparison = eq("qty", 5);
FindPublisher<Document> findPublisher = collection.find(equalComparison);
Flux.from(findPublisher)
        .doOnNext(doc -> System.out.println(doc.toJson()))
        .blockLast();

{ "_id": 1, "color": "red", "qty": 5, "vendor": ["A"] }
{ "_id": 6, "color": "pink", "qty": 5, "vendor": ["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 paint_purchases:

Bson gteComparison = gte("qty", 10);
FindPublisher<Document> findPublisher = collection.find(gteComparison);
Flux.from(findPublisher)
        .doOnNext(doc -> System.out.println(doc.toJson()))
        .blockLast();

{ "_id": 2, "color": "purple", "qty": 10, "vendor": ["C", "D"] }
{ "_id": 5, "color": "yellow", "qty": 11, "vendor": ["A", "B"] }

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

Bson emptyComparison = empty();
FindPublisher<Document> findPublisher = collection.find(emptyComparison);
Flux.from(findPublisher)
        .doOnNext(doc -> System.out.println(doc.toJson()))
        .blockLast();

{ "_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"] }
...

Lógica

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

Os métodos dos operadores lógicos 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 paint_purchases:

Bson orComparison = or(gt("qty", 8), eq("color", "pink"));
FindPublisher<Document> findPublisher = collection.find(orComparison);
Flux.from(findPublisher)
        .doOnNext(doc -> System.out.println(doc.toJson()))
        .blockLast();

{ "_id": 2, "color": "purple", "qty": 10, "vendor": ["C", "D"] }
{ "_id": 5, "color": "yellow", "qty": 11, "vendor": ["A", "B"] }
{ "_id": 6, "color": "pink", "qty": 5, "vendor": ["C"] }

arrays

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

Os métodos dos operadores de array incluem:

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

List<String> search = Arrays.asList("A", "D");
Bson allComparison = all("vendor", search);
FindPublisher<Document> findPublisher = collection.find(allComparison);
Flux.from(findPublisher)
        .doOnNext(doc -> System.out.println(doc.toJson()))
        .blockLast();

{ "_id": 8, "color": "orange", "qty": 7, "vendor": ["A", "D"] }

Elementos

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

Os métodos dos operadores de elementos incluem:

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

Bson existsComparison = and(exists("qty"), nin("qty", 5, 8));
FindPublisher<Document> findPublisher = collection.find(existsComparison);
Flux.from(findPublisher)
        .doOnNext(doc -> System.out.println(doc.toJson()))
        .blockLast();

{ "_id": 2, "color": "purple", "qty": 10, "vendor": ["C", "D"] }
{ "_id": 4, "color": "white", "qty": 6, "vendor": ["D"]}
{ "_id": 5, "color": "yellow", "qty": 11, "vendor": ["A", "B"] }
{ "_id": 8, "color": "orange", "qty": 7, "vendor": ["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 incluem:

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

Bson regexComparison = regex("color", "^p");
FindPublisher<Document> findPublisher = collection.find(regexComparison);
Flux.from(findPublisher)
        .doOnNext(doc -> System.out.println(doc.toJson()))
        .blockLast();

{ "_id": 2, "color": "purple", "qty": 10, "vendor": ["C", "D"] }
{ "_id": 6, "color": "pink", "qty": 5, "vendor": ["C"] }

Bitwise

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

Os métodos do operador bitwise incluem:

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

Bson bitsComparison = bitsAllSet("a", 34);
FindPublisher<Document> findPublisher = collection.find(bitsComparison);
Flux.from(findPublisher)
        .doOnNext(doc -> System.out.println(doc.toJson()))
        .blockLast();

{ "_id": 9, "a": 54, "binaryValue": "00110110" }
{ "_id": 12, "a": 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 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 na coleção geo_points:

Polygon square = new Polygon(Arrays.asList(
        new Position(0, 0),
        new Position(4, 0),
        new Position(4, 4),
        new Position(0, 4),
        new Position(0, 0)));
Bson geoWithinComparison = geoWithin("coordinates", square);
FindPublisher<Document> findPublisher = collection.find(geoWithinComparison);
Flux.from(findPublisher)
        .doOnNext(doc -> System.out.println(doc.toJson()))
        .blockLast();

{ "_id": 13, "coordinates": {"type": "Point", "coordinates": [2.0, 2.0]} }
{ "_id": 15, "coordinates": {"type": "Point", "coordinates": [1.0, 3.0]} }