Filtros desarrolladores

Overview

En esta guía, puedes aprender cómo usar constructores para especificar filtros en tus consultas con el controlador MongoDB Java.

Desarrolladores son clases proporcionadas por el controlador Java de MongoDB que te ayudan a construir objetos BSON. Para obtener más información, consulta nuestra guía sobre desarrolladores.

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

Algunos lugares donde usamos filtros son:

• find()

• etapa match de la 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 una piscina cubierta y estacionamiento gratuito

• Una revisión de un crítico gastronómico que menciona "picante"

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

• Comparación

• Lógica

• Arreglos

• Elementos

• Evaluación

• Bitwise

• Geoespacial

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

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

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

colecció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"] }

colecció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" }

colecció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 de operadores 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()));

Lo siguiente 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 en los que 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()));

Lo siguiente 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 de operador lógico incluyen:

El siguiente ejemplo crea un filtro que coincide con documentos donde el valor del campo qty es mayor que "8" o el valor del campo color es igual a "pink" 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()));

Lo siguiente 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 arreglos evalúan el campo del arreglo en un documento.

Los métodos de operador de arreglo incluyen:

El siguiente ejemplo empareja documentos con un arreglo 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()));

Lo siguiente 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 cuyo valor no equivale 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()));

Lo siguiente 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 empieza 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()));

Lo siguiente 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 a nivel de bits convierten un número en su valor binario para evaluar sus bits.

Los métodos del operador bit a bit incluyen:

El siguiente ejemplo encuentra documentos que tienen un campo bitField con bits activados 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()));

Lo siguiente 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 especificada y su relación con una forma o ubicación.

Los métodos de operador geoespacial incluyen:

El siguiente ejemplo crea un filtro que coincide con los documentos en los que el campo point contiene una geometría GeoJSON que se encuentra dentro del Polígono dado en la colección 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()));

Lo siguiente 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]} }