Constructores de filtros

Overview

En esta guía, puede aprender a utilizar constructores para especificar filtros para sus consultas en el controlador Java de MongoDB.

Los constructores son clases proporcionadas por el controlador Java de MongoDB que lo ayudan a construir ObjetosBSON. Para más información, consulte nuestra guía sobre constructores.

Los filtros son las operaciones que MongoDB utiliza para limitar los resultados a lo que desea ver.

Algunos lugares donde usamos filtros son:

• find()

• etapa de coincidencia de agregación

• deleteOne()/deleteMany()

• updateOne()/updateMany()

Algunos ejemplos de resultados de consultas con filtros son:

• Artículos que cuestan entre $0 y $25

• Un hotel con comodidades que incluyen piscina cubierta y estacionamiento gratuito.

• Una reseña de un crítico gastronómico que menciona "picante"

Esta guía le muestra cómo utilizar constructores con ejemplos de los siguientes tipos de operadores:

• Comparación

• Lógica

• Arreglos

• Elementos

• Evaluación

• Bitwise

• Geoespacial

La Filters clase proporciona métodos de fábrica estáticos para todos los operadores de consulta de MongoDB. Cada método devuelve una instancia del tipo BSON, que se puede pasar a cualquier método que espere un filtro de consulta.

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

Los ejemplos de filtros de esta guía utilizan las siguientes colecciones de muestra:

Recopilación: 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"] }

Recopilación: 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" }

Recopilación: 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] } }

Comparación

Los filtros de comparación incluyen todos los operadores que comparan el valor de un documento con un valor especificado.

Los métodos del operador de comparación incluyen:

El siguiente ejemplo crea un filtro que coincide con todos los documentos donde el valor del campo qty es igual a "5" en la colección paint_purchases:

Bson equalComparison = eq("qty", 5);
collection.find(equalComparison).forEach(doc -> System.out.println(doc.toJson()));

A continuación se muestra el resultado de la consulta anterior:

{ "_id": 1, "color": "red", "qty": 5, "vendor": ["A"] }
{ "_id": 6, "color": "pink", "qty": 5, "vendor": ["C"] }

El siguiente ejemplo crea un filtro que coincide con todos los documentos donde el valor del campo qty es mayor o igual a "10" en la colección paint_purchases:

Bson gteComparison = gte("qty", 10);
collection.find(gteComparison).forEach(doc -> System.out.println(doc.toJson()));

A continuación se muestra el resultado de la consulta anterior:

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

El siguiente ejemplo crea un filtro que empareja todos los documentos en la colección paint_purchases porque el predicado está vacío:

Bson emptyComparison = empty();
collection.find(emptyComparison).forEach(doc -> System.out.println(doc.toJson()));

La salida de la query previa consiste en todos los documentos de la colección.

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

Los operadores lógicos realizan operaciones lógicas basadas en las condiciones del método especificado.

Los métodos del operador lógico incluyen:

El siguiente ejemplo crea un filtro que coincide con los documentos donde el valor del campo qty es mayor que "8" o el valor del campo color es igual a "rosa" en la colección paint_purchases:

Bson orComparison = or(gt("qty", 8), eq("color", "pink"));
collection.find(orComparison).forEach(doc -> System.out.println(doc.toJson()));

A continuación se muestra el resultado de la consulta 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"] }

Arreglos

Los operadores de matriz evalúan el campo de matriz en un documento.

Los métodos del operador de matriz incluyen:

El siguiente ejemplo coincide con documentos con una matriz vendors que contiene tanto "A" como "D" en la colección paint_purchases:

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

A continuación se muestra el resultado de la consulta anterior:

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

Elementos

Los operadores de elementos evalúan la naturaleza de un campo especificado.

Los métodos del operador de elementos incluyen:

El siguiente ejemplo coincide con documentos que tienen un campo qty y su valor no es igual a "5" o "8" en la colección paint_purchases:

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

A continuación se muestra el resultado de la consulta 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"] }

Evaluación

Los operadores de evaluación evalúan el valor de cualquier campo en un documento.

Los métodos del operador de evaluación incluyen:

El siguiente ejemplo coincide con documentos que tienen un campo color que comienza con la letra "p" en la colección paint_purchases:

Bson regexComparison = regex("color", "^p");
collection.find(regexComparison).forEach(doc -> System.out.println(doc.toJson()));

A continuación se muestra el resultado de la consulta anterior:

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

Bitwise

Los operadores bit a bit convierten un número en su valor binario para evaluar sus bits.

Los métodos de operador bit a bit incluyen:

El siguiente ejemplo coincide con documentos que tienen un campo bitField con bits establecidos en posiciones de la máscara de bits correspondiente "34" (es decir, "00100010") en la colección binary_numbers:

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

A continuación se muestra el resultado de la consulta anterior:

{ "_id": 9, "a": 54, "binaryValue": "00110110" }
{ "_id": 12, "a": 102, "binaryValue": "01100110" }

Geoespacial

Los operadores geoespaciales evalúan una coordenada específica y su relación con una forma o ubicación.

Los métodos del operador geoespacial incluyen:

El siguiente ejemplo crea un filtro que coincide con los documentos en los que el point campo contiene una geometría GeoJSON que se encuentra dentro del polígono dado en la geo_points colección:

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()));

A continuación se muestra el resultado de la consulta anterior:

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