Especifica un query

Overview

En esta guía, puede aprender a especificar una consulta mediante el controlador Java Reactive Streams.

Esta guía utiliza el Flux Publisher, el cual es una implementación Publisher de la biblioteca Project Reactor. En Java Reactive Streams, debes utilizar implementaciones de Publisher para controlar cómo se transmite la información en tu aplicación. Para aprender más sobre la clase Flux, consulta Flux en la documentación de Project Reactor.

Puede refinar el conjunto de documentos que una query devuelve creando un filtro de query. Un filtro de query es una expresión que especifica los criterios de búsqueda que MongoDB utiliza para coincidir con documentos en una operación de lectura o escritura. En un filtro de query, puede pedirle al driver que busque documentos que coincidan exactamente con su query, o puede elaborar filtros de query para expresar criterios de coincidencia más complejos.

{ "_id": 1, "name": "apples", "qty": 5, "rating": 3, "color": "red", "type": ["fuji", "honeycrisp"] },
{ "_id": 2, "name": "bananas", "qty": 7, "rating": 4, "color": "yellow", "type": ["cavendish"] },
{ "_id": 3, "name": "oranges", "qty": 6, "rating": 2, "type": ["naval", "mandarin"] },
{ "_id": 4, "name": "pineapple", "qty": 3, "rating": 5, "color": "yellow" },

import com.mongodb.ConnectionString;
import com.mongodb.MongoClientSettings;
import com.mongodb.ServerApi;
import com.mongodb.ServerApiVersion;
import com.mongodb.client.result.InsertManyResult;
import org.bson.Document;
import org.reactivestreams.Publisher;
import reactor.core.publisher.Mono;
import com.mongodb.reactivestreams.client.MongoClient;
import com.mongodb.reactivestreams.client.MongoClients;
import com.mongodb.reactivestreams.client.MongoDatabase;
import com.mongodb.reactivestreams.client.MongoCollection;
import java.util.Arrays;
import java.util.List;
public class QueryDatabase {
    public static void main(String[] args) {
        // Replace the placeholder with your Atlas connection string
        String uri = "<connection string>";
        // Construct a ServerApi instance using the ServerApi.builder() method
        ServerApi serverApi = ServerApi.builder()
                .version(ServerApiVersion.V1)
                .build();
        MongoClientSettings settings = MongoClientSettings.builder()
                .applyConnectionString(new ConnectionString(uri))
                .serverApi(serverApi)
                .build();
        // Create a new client and connect to the server
        try (MongoClient mongoClient = MongoClients.create(settings)) {
            MongoDatabase database = mongoClient.getDatabase("sample_fruits");
            MongoCollection<Document> fruits = database.getCollection("fruits");
            Document document1 = new Document("_id", "1")
                    .append("name", "apples")
                    .append("qty", 5)
                    .append("rating", 3)
                    .append("color", "red")
                    .append("type", Arrays.asList("fuji", "honeycrisp"));
            Document document2 = new Document("_id", "2")
                    .append("name", "bananas")
                    .append("qty", 7)
                    .append("rating", 4)
                    .append("color", "yellow")
                    .append("type", Arrays.asList("cavendish"));
            Document document3 = new Document("_id", "3")
                    .append("name", "oranges")
                    .append("qty", 6)
                    .append("rating", 2)
                    .append("type", Arrays.asList("naval", "mandarin"));
            Document document4 = new Document("_id", "4")
                    .append("name", "pineapple")
                    .append("qty", 3)
                    .append("rating", 5)
                    .append("color", "yellow");
            List<Document> documents = Arrays.asList(document1, document2, document3, document4);
            Publisher<InsertManyResult> insertPublisher = fruits.insertMany(documents);
            Mono.from(insertPublisher).block();                                                        
        }
    }
}

Coincidencia exacta

Las consultas de valores literales devuelven documentos que coinciden exactamente con su filtro de query. Para devolver documentos con una coincidencia exacta, utilice el método de operador de comparación eq().

El siguiente ejemplo especifica un método operador de comparación eq() como parámetro de filtro de query en el método find(). El código devuelve todos los documentos con un valor de campo color de "yellow".

FindPublisher<Document> findDocPublisher = fruits.find(eq("color", "yellow"));
Document findResults = Flux.from(findDocPublisher)
         .doOnNext(System.out::println)
         .blockLast();

{'_id': 2, 'name': 'bananas', 'qty': 7, 'rating': 4, 'color': 'yellow', 'type': ['cavendish']}
{'_id': 4, 'name': 'pineapple', 'qty': 3, 'rating': 5, 'color': 'yellow'}

FindPublisher<Document> findDocPublisher = fruits.find();
Document findResults = Flux.from(findDocPublisher)
         .doOnNext(System.out::println)
         .blockLast();

Operadores de comparación

Los operadores de comparación evalúan el valor de un campo de documento con respecto a un valor especificado en tu filtro de query. La siguiente es una lista de métodos comunes de operadores de comparación:

• gt(): Mayor que

• lte()Menor o igual

• ne():No es igual

Para ver una lista completa de operadores de comparación, consulte la guía Operadores de consulta de comparación en el manual de MongoDB Server.

En el siguiente ejemplo, se especifica un método de operador de comparación gt() en un filtro de query como parámetro para el método find(). El código devuelve todos los documentos cuyo valor de campo rating es mayor que 2.

FindPublisher<Document> findDocPublisher = fruits.find(gt("rating", 2));
Document findResults = Flux.from(findDocPublisher)
         .doOnNext(System.out::println)
         .blockLast();

{'_id': 1, 'name': 'apples', 'qty': 5, 'rating': 3, 'color': 'red', 'type': ['fuji', 'honeycrisp']}
{'_id': 2, 'name': 'bananas', 'qty': 7, 'rating': 4, 'color': 'yellow', 'type': ['cavendish']}
{'_id': 4, 'name': 'pineapple', 'qty': 3, 'rating': 5, 'color': 'yellow'}

Operadores lógicos

Los operadores lógicos vinculan documentos mediante la lógica aplicada a los resultados de dos o más conjuntos de expresiones. A continuación, se muestra una lista de métodos de operadores lógicos:

• and(), que devuelve todos los documentos que coinciden con las condiciones de todas las cláusulas

• or(), que devuelve todos los documentos que coinciden con las condiciones de una cláusula

• nor()que devuelve todos los documentos que no cumplen las condiciones de ninguna cláusula

• not()que devuelve todos los documentos que no coinciden con la expresión

Para obtener más información sobre los operadores lógicos, consulta la guía Operadores de consulta lógica en el manual del MongoDB Server.

El siguiente ejemplo especifica un método de operador lógico or() en un filtro de query como parámetro para el método find(). El código devuelve todos los documentos con un valor de campo qty mayor que 5 o un valor de campo color de "yellow".

FindPublisher<Document> findDocPublisher = fruits.find(
        or(gt("qty", 5), eq("color", "yellow")));
Document findResults = Flux.from(findDocPublisher)
         .doOnNext(System.out::println)
         .blockLast();

{'_id': 2, 'name': 'bananas', 'qty': 7, 'rating': 4, 'color': 'yellow', 'type': ['cavendish']}
{'_id': 3, 'name': 'oranges', 'qty': 6, 'rating': 2, 'type': ['naval', 'mandarin']}
{'_id': 4, 'name': 'pineapple', 'qty': 3, 'rating': 5, 'color': 'yellow'}

Operadores de arreglos

Los operadores de arreglo emparejan documentos según el valor o la cantidad de elementos en un campo de arreglo. La siguiente es una lista de los métodos de operadores de arreglo disponibles:

• all()que devuelve documentos con arreglos que contienen todos los elementos en la query

• elemMatch(), que devuelve documentos si un elemento en su campo de matriz coincide con todas las condiciones de la consulta

• size(), que devuelve todos los documentos con arreglos de un tamaño específico

Para obtener más información sobre los operadores de arreglo, consulta la guía Operadores del query de arreglo en el manual de MongoDB Server.

El siguiente ejemplo especifica un método de size() operador de arreglos en un filtro de query como parámetro del método find(). El código regresa todos los documentos con un campo de arreglo type que contiene 2 elementos.

FindPublisher<Document> findDocPublisher = fruits.find(size("type", 2));
Document findResults = Flux.from(findDocPublisher)
         .doOnNext(System.out::println)
         .blockLast();

{'_id': 1, 'name': 'apples', 'qty': 5, 'rating': 3, 'color': 'red', 'type': ['fuji', 'honeycrisp']}
{'_id': 3, 'name': 'oranges', 'qty': 6, 'rating': 2, 'type': ['naval', 'mandarin']}

Operadores de elementos

Los operadores de elementos consultan datos según la presencia o el tipo de campo. A continuación, se muestra una lista de los métodos de operadores de elementos disponibles:

• exists()que devuelve documentos con el campo especificado

• type(), que devuelve documentos si un campo es del tipo especificado

Para obtener más información sobre los operadores de elementos, consulte la guía Operadores de consulta de elementos en el manual de MongoDB Server.

El siguiente ejemplo especifica un método de operador del elemento exists() en un filtro de query como parámetro del método find(). El código devuelve todos los documentos que tienen un campo color.

FindPublisher<Document> findDocPublisher = fruits.find(exists("color", true));
Document findResults = Flux.from(findDocPublisher)
         .doOnNext(System.out::println)
         .blockLast();

{'_id': 1, 'name': 'apples', 'qty': 5, 'rating': 3, 'color': 'red', 'type': ['fuji', 'honeycrisp']}
{'_id': 2, 'name': 'bananas', 'qty': 7, 'rating': 4, 'color': 'yellow', 'type': ['cavendish']}
{'_id': 4, 'name': 'pineapple', 'qty': 3, 'rating': 5, 'color': 'yellow'}

Operadores de evaluación

Los operadores de evaluación devuelven datos basados en evaluaciones de campos individuales o de todos los documentos de la colección. La siguiente es una lista de métodos de operadores de evaluación comunes:

• text(), que realiza uma query de texto nos documentos

• regex(), que devuelve documentos que coinciden con una expresión regular especificada

• mod(), que realiza una operación de módulo sobre el valor de un campo y devuelve documentos donde el resto es un valor especificado

Para ver una lista completa de operadores de evaluación, consulta la guía Operadores de consulta de evaluación en el manual del MongoDB Server.

El siguiente ejemplo especifica un método de operador de evaluación regex() en un filtro de consulta como parámetro del método find(). El código utiliza una expresión regular para devolver todos los documentos con un valor de campo name que contenga al menos dos caracteres "p" consecutivos.

FindPublisher<Document> findDocPublisher = fruits.find(regex("name", "p{2,}"));
Document findResults = Flux.from(findDocPublisher)
         .doOnNext(System.out::println)
         .blockLast();

{'_id': 1, 'name': 'apples', 'qty': 5, 'rating': 3, 'color': 'red', 'type': ['fuji', 'honeycrisp']}
{'_id': 4, 'name': 'pineapple', 'qty': 3, 'rating': 5, 'color': 'yellow'}

Información Adicional

Para aprender más sobre cómo realizar consultas de documentos, consulta la guía Consultar documentos en el manual de MongoDB Server.