Menu Docs
Página inicial do Docs
/
Línguas
/
Java
/
Driver de sincronização Java
/
Fundamentos
/
Construtores

Construtores de filtros

Nesta página

  • Visão geral
  • Comparação
  • Lógica
  • arrays
  • Elementos
  • Avaliação
  • Bit a bit
  • Geoespacial

Visão geral

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

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

Os filtros são as operações que o MongoDB usa para limitar seus resultados ao que você deseja ver.

Alguns lugares onde usamos filtros são:

  • find()

  • estágio de aggregation de correspondência

  • deleteOne()/deleteMany()

  • updateOne()/updateMany()

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

  • Itens que custam de US$ 0 a US$ 25

  • Um hotel com comodidades que incluem piscina coberta e estacionamento gratuito

  • 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.

Dica

Para maior brevidade, você pode optar por importar todos os métodos dos Filtros classe estaticamente:

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

Os exemplos a seguir pressupõem essa importação estática.

Os exemplos de filtros neste 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:

Método de comparação
Partidas
eq()
valores iguais a um valor especificado.
gt()
valores superiores a um valor especificado.
gte()
valores maiores ou iguais a um valor especificado.
lt()
valores menores que um valor especificado.
lte()
valores menores ou iguais a um valor especificado.
ne()
valores não iguais a um valor especificado.
in()
qualquer um dos valores especificados em uma array.
nin()
nenhum dos valores especificados em uma array.
empty()
todos os documentos.

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);
collection.find(equalComparison).forEach(doc -> System.out.println(doc.toJson()));

O seguinte mostra a saída da query anterior:

{ "_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);
collection.find(gteComparison).forEach(doc -> System.out.println(doc.toJson()));

O seguinte mostra a saída da query anterior:

{ "_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();
collection.find(emptyComparison).forEach(doc -> System.out.println(doc.toJson()));

A saída da query anterior consiste em todos os documentos da collection.

{ "_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:

Método lógico
Partidas
and()
documentos com as condições de todos os filtros. Este operador une filtros com um AND lógico.
or()
documentos com as condições de qualquer um dos filtros. Este operador une filtros com um OR lógico.
not()
documentos que não correspondem ao filtro.
nor()
documentos que não correspondem a ambos os filtros. Este operador une filtros com um NOR lógico.

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"));
collection.find(orComparison).forEach(doc -> System.out.println(doc.toJson()));

O seguinte mostra a saída da query anterior:

{ "_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:

Método de array
Partidas
all()
documentos, se o campo array contiver todos os elementos especificados na query.
elemMatch()
documentos, se um elemento no campo array corresponder a todas as condições especificadas.
size()
documentos, se o campo array for um número específico de elementos.

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

List<String> search = Arrays.asList("A", "D");
Bson allComparison = all("vendor", search);
collection.find(allComparison).forEach(doc -> System.out.println(doc.toJson()));

O seguinte mostra a saída da query anterior:

{ "_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:

Método de elementos
Partidas
exists()
documentos que tenham o campo especificado.
type()
documentos, se um campo for do tipo especificado.

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

Bson existsComparison = and(exists("qty"), nin("qty", 5, 8));
collection.find(existsComparison).forEach(doc -> System.out.println(doc.toJson()));

O seguinte mostra a saída da query anterior:

{ "_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:

Método de avaliação
Partidas
mod()
documentos onde uma operação de módulo em um valor de campo produz um resultado especificado.
regex()
documentos onde os valores contêm uma expressão regular especificada.
text()
documentos que contêm uma expressão de pesquisa de texto completo especificada.
where()
documentos que contêm uma expressão JavaScript especificada.

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");
collection.find(regexComparison).forEach(doc -> System.out.println(doc.toJson()));

O seguinte mostra a saída da query anterior:

{ "_id": 2, "color": "purple", "qty": 10, "vendor": ["C", "D"] }
{ "_id": 6, "color": "pink", "qty": 5, "vendor": ["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 incluem:

Método bitwise
Partidas
bitsAllSet()
documentos onde os bits especificados de um campo são definidos (ou seja, "1").
bitsAllClear()
documentos onde os bits especificados de um campo estão limpos (ou seja, "0").
bitsAnySet()
documentos onde pelo menos um dos bits especificados de um campo está definido (ou seja, "1").
bitsAnyClear()
documentos onde pelo menos um dos bits especificados de um campo está limpo (ou seja, "0").

O exemplo a seguir combina documentos que têm um campo bitField com bits definidos nas posições da máscara de bits correspondente "34" (i.e. "00100010") na collection binary_numbers:

Bson bitsComparison = bitsAllSet("a", 34);
collection.find(bitsComparison).forEach(doc -> System.out.println(doc.toJson()));

O seguinte mostra a saída da query anterior:

{ "_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:

Método geoespacial
Partidas
geoWithin()
documentos quem têm um valor de geometria GeoJSON que cai dentro de uma geometria GeoJSON delimitadora.
geoWithinBox()
documentos contendo um valor de coordenadas que existem dentro da caixa especificada.
geoWithinPolygon()
documentos contendo um valor de coordenadas que existem dentro do polígono especificado.
geoWithinCenter()
documentos contendo um valor de coordenadas que existem dentro do círculo especificado.
geoWithinCenterSphere()
geometrias que contêm um valor de dados geoespaciais (GeoJSON ou pares de coordenadas legados) que existem dentro do círculo especificado, utilizando geometria esférica.
geoIntersects()
geometria que interseccionam com uma geometria GeoJSON. O índice 2dsphere suporta $geoIntersects.
near()
objetos geoespaciais próximos a um ponto. Requer um índice geoespacial. Os índices 2dsphere e 2d suportam $near.
nearSphere()
objetos geoespaciais próximos a um ponto em uma esfera. Requer um índice geoespacial. Os índices 2dsphere e 2d suportam $nearSphere.

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)));
// Prints documents that contain "coordinates" values that are within the bounds of the polygon passed as the filter parameter
Bson geoWithinComparison = geoWithin("coordinates", square);
collection.find(geoWithinComparison).forEach(doc -> System.out.println(doc.toJson()));

O seguinte mostra a saída da query anterior:

{ "_id": 13, "coordinates": {"type": "Point", "coordinates": [2.0, 2.0]} }
{ "_id": 15, "coordinates": {"type": "Point", "coordinates": [1.0, 3.0]} }
← Construtores de agregados
Construtores de índices →

Nesta página