Especifica un query

Overview

En esta guía, puedes aprender cómo especificar una query usando el driver Scala.

Se puede refinar el conjunto de documentos que una query retorna creando un filtro de query. Un filtro de query es una expresión que especifica el criterio de búsqueda que MongoDB usa para hacer coincidir documentos en una operación de lectura o escritura.

Puedes utilizar operadores del query para expresar criterios de coincidencia más complejos en un filtro de query. El driver de Scala incluye una clase Filters que proporciona métodos asistente para aplicar operadores del query.

val uri: String = "<connection string>"
val client: MongoClient = MongoClient(uri)
val database: MongoDatabase = client.getDatabase("db")
val collection: MongoCollection[Document] = database.getCollection("fruits")
// Inserts documents representing fruits
val fruits: Seq[Document] = Seq(
    Document("_id" -> 1, "name" -> "apples", "qty" -> 5, "rating" -> 3, "color" -> "red", "type" -> Seq("fuji", "honeycrisp")),
    Document("_id" -> 2, "name" -> "bananas", "qty" -> 7, "rating" -> 4, "color" -> "yellow", "type" -> Seq("cavendish")),
    Document("_id" -> 3, "name" -> "oranges", "qty" -> 6, "rating" -> 2, "type" -> Seq("naval", "mandarin")),
    Document("_id" -> 4, "name" -> "pineapples", "qty" -> 3, "rating" -> 5, "color" -> "yellow")
)
val result = collection.insertMany(fruits)
                       .subscribe((result: InsertManyResult) => println(result))

Coincidencia exacta

Las queries de valor literal retornan documentos que tienen una coincidencia exacta con su filtro de query.

El siguiente ejemplo especifica un filtro de query como parámetro para el método find(). El código devuelve todos los documentos en los que el valor del campo color es "yellow":

val filter = equal("color", "yellow")
collection.find(filter).subscribe((doc: Document) => println(doc.toJson()),
                            (e: Throwable) => println(s"There was an error: $e"))

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

collection.find()

Operadores de comparación

Los operadores de comparación evalúan el valor de un campo de documento en relación con un valor especificado en tu filtro de query. La siguiente lista define los operadores de comparación comunes y sus correspondientes métodos asistentes Filters:

El siguiente ejemplo pasa un filtro de query al método find() y utiliza el método gt() para aplicar el operador de comparación $gt. El código devuelve todos los documentos en los que el valor del campo rating es superior a 2:

val filter = gt("rating", 2)
collection.find(filter).subscribe((doc: Document) => println(doc.toJson()),
                            (e: Throwable) => println(s"There was an error: $e"))

{"_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": "pineapples", "qty": 3, "rating": 5, "color": "yellow"}

Operadores lógicos

Los operadores lógicos coinciden con los documentos utilizando la lógica aplicada a los resultados de dos o más conjuntos de expresiones. La siguiente tabla describe cada operador lógico y su correspondiente método asistente Filters:

En el siguiente ejemplo, se pasa un filtro de query al método find() y se utiliza el or() método para aplicar el operador lógico $or. El código devuelve todos los documentos en los que el campo qty tenga un valor mayor que 5 o el campo color tenga "yellow":

val filter = or(gt("qty", 5), equal("color", "yellow"))
collection.find(filter).subscribe((doc: Document) => println(doc.toJson()),
                            (e: Throwable) => println(s"There was an error: $e"))

{"_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": "pineapples", "qty": 3, "rating": 5, "color": "yellow"}

Operadores de arreglos

Los operadores de arreglos emparejan documentos según el valor o la cantidad de elementos en un campo de arreglo. La siguiente tabla describe cada operador de arreglo y su correspondiente método asistente Filters:

El siguiente ejemplo pasa un filtro de query al método find() y utiliza el método size() para aplicar el operador de arreglo $size. El código devuelve todos los documentos en los que el campo de arreglo type contiene 2 elementos:

val filter = size("type", 2)
collection.find(filter).subscribe((doc: Document) => println(doc.toJson()),
                            (e: Throwable) => println(s"There was an error: $e"))

{"_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 query según la presencia o el tipo de un campo. La siguiente tabla describe cada operador de elemento y su correspondiente método auxiliar Filters:

El siguiente ejemplo pasa un filtro de query al método find() y utiliza el método exists() para aplicar el operador de elemento $exists. El código devuelve todos los documentos que tienen un campo color:

val filter = exists("color")
collection.find(filter).subscribe((doc: Document) => println(doc.toJson()),
                            (e: Throwable) => println(s"There was an error: $e"))

{"_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": "pineapples", "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 los documentos de toda la colección. La siguiente tabla describe los operadores de elementos comunes y sus métodos asistentes Filters correspondientes:

El siguiente ejemplo pasa un filtro de query al método find() y utiliza el método regex() para aplicar el operador de evaluación $regex. El código utiliza una expresión regular para devolver todos los documentos en los que el valor del campo name tenga al menos dos caracteres consecutivos 'p' :

val filter = regex("name", "p{2,}")
collection.find(filter).subscribe((doc: Document) => println(doc.toJson()),
                            (e: Throwable) => println(s"There was an error: $e"))

{"_id": 1, "name": "apples", "qty": 5, "rating": 3, "color": "red", "type": ["fuji", "honeycrisp"]}
{"_id": 4, "name": "pineapples", "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.

Si deseas aprender más sobre la recuperación de documentos con el driver de Scala, consulta la guía Recuperar datos.