Especificar uma query

Visão geral

Neste guia, você pode aprender como especificar uma query usando o driver Java Reactive Streams.

Este guia usa o Flux Publisher, que é uma implementação do Publisher da biblioteca do Projeto Reactor. Nos Java Reactive Streams, você deve usar implementações Publisher para controlar como os dados são transmitidos em seu aplicação. Para saber mais sobre a Flux classe , consulte Flux na documentação do Projeto Reactor.

Você pode refinar o conjunto de documentos que uma query retorna criando um filtro de query. Um filtro de query é uma expressão que especifica os critérios do Atlas Search que o MongoDB usa para corresponder a documentos em uma operação de leitura ou gravação. Em um filtro de query, você pode solicitar ao driver para Atlas Search documentos com uma correspondência exata à sua query, ou você pode compor filtros de query para Express critérios de correspondência mais complexos.

{ "_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();                                                        
        }
    }
}

Correspondência exata

Consultas de valor literal retornam documentos com uma correspondência exata ao seu filtro de consulta. Para retornar documentos com uma correspondência exata, use o método eq() do operador de comparação.

O exemplo a seguir especifica um método de operador de comparação eq() como parâmetro de filtro de query no método find() . O código retorna todos os documentos com um 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 comparação

Os operadores de comparação avaliam um valor de campo de documento em relação a um valor especificado em seu filtro de query. Veja a seguir uma lista de métodos comuns de operadores de comparação:

• gt(): Maior que

• lte(): Menor ou Igual

• ne(): Diferente

Para visualizar uma lista completa de operadores de comparação, consulte o guia Operadores de query de comparação no manual do MongoDB Server .

O exemplo a seguir especifica um método de operador de comparação gt() em um filtro de query como um parâmetro para o método find() . O código retorna todos os documentos com um valor de campo rating maior 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

Os operadores lógicos correspondem aos documentos usando lógica aplicada aos resultados de dois ou mais conjuntos de expressões. Veja a seguir uma lista de métodos de operadores lógicos:

• and(), que retorna todos os documentos que correspondem às condições de todas as cláusulas

• or(), que retorna todos os documentos que correspondem às condições de uma cláusula

• nor(), que retorna todos os documentos que não correspondem às condições de nenhuma cláusula

• not(), que retorna todos os documentos que não correspondem à expressão

Para saber mais sobre operadores lógicos, consulte o guia Operadores lógicos de query no manual do MongoDB Server .

O exemplo seguinte especifica um método de operador lógico or() em um filtro de query como um parâmetro para o método find() . O código retorna todos os documentos com um valor de campo qty maior que 5 ou um 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 array

Os operadores de array correspondem aos documentos com base no valor ou na quantidade de elementos em um campo de array . A seguir está uma lista de métodos do operador de array disponíveis:

• all(), que retorna documentos com arrays que contêm todos os elementos da query

• elemMatch(), que retorna documentos se um elemento em seu campo de array corresponder a todas as condições na query

• size(), que retorna todos os documentos com arrays de um tamanho especificado

Para saber mais sobre operadores de array, consulte o guia Operadores de query de array no manual do MongoDB Server .

O exemplo a seguir especifica um método de operador de array size() em um filtro de query como um parâmetro para o método find() . O código retorna todos os documentos com um campo de array type contendo 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

Os operadores de elemento consultam os dados com base na presença ou tipo de campo. Veja a seguir uma lista dos métodos do operador de elementos disponíveis:

• exists(), que retorna documentos com o campo especificado

• type(), que retorna documentos se um campo for do tipo especificado

Para saber mais sobre os operadores de elementos, consulte o guia Operadores de query de elementos no manual do MongoDB Server .

O exemplo seguinte especifica um método de operador de elemento exists() em um filtro de query como um parâmetro para o método find() . O código retorna todos os documentos que têm um 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 avaliação

Os operadores de avaliação retornam dados com base em avaliações de campos individuais ou documentos de toda a coleção. Veja a seguir uma lista de métodos comuns de operadores de avaliação:

• text(), que executa um Atlas Search de texto nos documentos

• regex(), que retorna documentos que correspondem a uma expressão regular especificada

• mod(), que executa um módulo operação no valor de um campo e retorna documentos onde o restante é um valor especificado

Para visualizar uma lista completa de operadores de avaliação, consulte o guia Operadores de query de avaliação no manual do MongoDB Server .

O exemplo seguinte especifica um método de operador de avaliação regex() em um filtro de query como um parâmetro para o método find() . O código usa uma expressão regular para retornar todos os documentos com um valor de campo name que tenha pelo menos dois "p" caracteres 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'}

Informações adicionais

Para saber mais sobre como query documentos, consulte o guia Consultar documentos no manual do MongoDB Server .