Especifica un query

Overview

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

Puede refinar el conjunto de documentos que devuelve una consulta creando un filtro de consulta. Un filtro de consulta es una expresión que especifica los criterios de búsqueda que MongoDB utiliza para encontrar documentos en una operación de lectura o escritura.

Puede usar operadores de consulta para expresar criterios de coincidencia más complejos en un filtro de consulta. El controlador de Scala incluye un Filters clase que proporciona métodos auxiliares para aplicar operadores de consulta.

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 consultas de valor literal devuelven documentos que coinciden exactamente con su filtro de consulta.

El siguiente ejemplo especifica un filtro de consulta como parámetro del método find(). El código devuelve todos los documentos cuyo 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 con respecto a un valor especificado en el filtro de consulta. La siguiente lista define operadores de comparación comunes y sus correspondientes métodos auxiliares Filters:

El siguiente ejemplo pasa un filtro de consulta 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 cuyo valor del campo rating sea mayor que 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 comparan documentos mediante 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 método auxiliar Filters correspondiente:

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

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 matriz buscan coincidencias de documentos según el valor o la cantidad de elementos en un campo de matriz. La siguiente tabla describe cada operador de matriz y su método auxiliar Filters correspondiente:

El siguiente ejemplo pasa un filtro de consulta al método find() y utiliza el método size() para aplicar el operador de matriz $size. El código devuelve todos los documentos en los que el campo de matriz 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 datos según la presencia o el tipo de campo. La siguiente tabla describe cada operador de elemento y su método auxiliar Filters correspondiente:

El siguiente ejemplo pasa un filtro de consulta 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 correspondientes métodos auxiliares Filters:

El siguiente ejemplo pasa un filtro de consulta 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 cuyo valor del campo name tenga al menos dos caracteres 'p' consecutivos:

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 obtener más información sobre cómo consultar documentos, consulte la guía Consultar documentos en el manual de MongoDB Server.

Para obtener más información sobre cómo recuperar documentos con el controlador Scala, consulte la Guíade recuperación de datos.