MongoDB queries: cómo funcionan las consultas de datos

Con las consultas de MongoDB (también queries) puedes buscar y analizar tu base de datos de forma rápida y eficaz. La estructura del método es muy lógica y permite utilizar parámetros para acotar las consultas.

Búsqueda eficaz en colecciones

MongoDB es una solución NoSQL documental con la que se pueden almacenar y gestionar fácilmente cantidades de datos grandes y diversas. El sistema gestor de bases de datos es muy flexible y tiene una sencilla escalabilidad horizontal.

A diferencia de las bases de datos relacionales, en este caso los datos se almacenan en documentos BSON (JSON binario) y se agrupan en colecciones. No obstante, para que esto ocurra, se requieren potentes mecanismos de consulta que puedan filtrar la base de datos y solo presenten la información que se necesita. Estas consultas de MongoDB buscan incluso en colecciones complejas y proporcionan la información que se busca.

¿Qué son las consultas de MongoDB?

MongoDB queries es una herramienta intuitiva que sirve para buscar en estructuras de datos complejas. Sigue reglas lógicas y funciona como las opciones de filtro de muchas páginas web, por lo que es posible realizar una búsqueda muy acotada y obtener los mejores resultados. Esto es especialmente importante, ya que MongoDB permite almacenar muchos tipos diferentes de datos y, de no existir las opciones de filtrado necesarias, sería difícil gestionar una base de datos. A continuación, explicamos paso a paso cómo crear fácilmente queries en MongoDB y cómo utilizarlas.

¿Qué requisitos hay que cumplir para usar las MongoDB queries?

Para utilizar las MongoDB queries, solo son necesarios algunos requisitos.

1. Primero, debes instalar MongoDB en tu ordenador. La base de datos funciona en muchos sistemas operativos, por lo que puedes seguir estas instrucciones con Linux, OS X o Windows. Los pasos posteriores a la instalación son los mismos en todos los sistemas y solo afectan a la propia base de datos. En nuestro tutorial de MongoDB puedes leer cómo funciona la instalación.
2. Para utilizar la función de búsqueda deben tenerse derechos de administrador.
3. Lo mejor es crear un entorno de prueba para utilizar por primera vez el método sin riesgos. A continuación, te explicamos qué pasos seguir.

Estructura de una colección de prueba

Primero, abre la Shell e inicia sesión con tus datos de administrador. A continuación, crea una nueva colección, que va a servir de entorno de prueba para que realices tus primeras MongoDB queries. El método no solo tiene en cuenta documentos simples, sino también arrays, varios campos y documentos incrustados. Para demostrar el alcance de las MongoDB queries, vamos a crear una colección un poco más compleja.

Como ejemplo vamos a tener una lista de clientes. El formato debe ser el siguiente:

{
    "name" : "Sanz",
    "units" : 642,
    "location" : [ "Germany", "Austria" ],
    "transactions" : {
        "first" : {
            "year" : 2017,
        },
        "last" : {
            "year" : 2023,
        },
        "total" : 14
    }
}

Este documento contiene la siguiente información:

• name: el nombre de la empresa del cliente que ha vendido la mercancía.
• units: la cantidad total de productos que ha pedido la empresa.
• location: la sede de la otra empresa. Si hubiera más filiales, estas pueden guardarse en forma de matriz.
• transactions: este campo contiene ahora otro documento que se incrusta o anida (en inglés se habla de “embedded documents” o “nested documents”). Cada documento de transacción contiene información sobre el tiempo que la empresa lleva siendo cliente (en el punto “first”), cuándo se realizó el último pedido (en el punto “last”) y, por último, cuántas veces ha realizado pedidos (en el punto “total”).

En este caso, los documentos adicionales se han incluido para poder añadir más información con posterioridad. Así los datos siguen estando organizados.

Creación de la colección de prueba para las MongoDB queries

Ahora vamos a crear una colección llamada “Clientes”, que en nuestro ejemplo debería contener solo cinco entradas para una mejor organización. Si más adelante quisieras utilizar MongoDB queries de forma profesional, podrías crear colecciones mucho más extensas mediante el método insertMany. Así quedaría nuestro ejemplo:

db.clientes.insertMany ( [
{
    "name" : "Sanz",
    "units" : 642,
    "location" : [ "Germany", "Austria" ],
    "transactions" : {
        "first" : {
            "year" : 2017,
        },
        "last" : {
            "year" : 2023,
        },
        "total" : 14
    }
},
{
    "name" : "ATS",
    "units" : 17,
    "location" : "France",
    "transactions" : {
        "first" : {
            "year" : 2021,
        },
        "last" : {
            "year" : 2022,
        },
        "total" : 2,
    }
},
{
    "name" : "Murillo",
    "units" : 814,
    "location" : [ "Austria", "Germany" ],
    "transactions" : {
        "first" : {
            "year" : 2016,
        },
        "last" : {
            "year" : 2023,
        },
        "total" : 22,
    }
},
{
    "name" : "Pawolski",
    "units" : 313,
    "location" : [ "Germany", "Poland" ],
    "transactions" : {
            "first" : {
            "year" : 2017,
            },
        "last" : {
            "year" : 2020,
        },
        "total" : 9,
    }
},
{
    "name" : "Jorgensen",
    "units" : 7,
    "location" : "Dinamarca",
    "transactions" : {
        "first" : {
            "year" : 2022,
        },
        "last" : {
            "year" : 2023,
        },
        "total" : 2,
    }
}
] )

Si copias esta entrada o la rellenas con tus propios datos, recibirás una lista de los ID de objeto asignados. Estos son únicos y garantizan que cada documento pueda encontrarse también a través del ID. Si quieres asegurarte de que todos los documentos se han transferido a la colección, puedes utilizar MongoDB find en lugar de seguir introduciendo parámetros adicionales:

db.clientes.find ( )

Como resultado se obtiene un listado de todos los Object ID con los documentos completos, que ahora podrás explorar con MongoDB queries.

Consultar campos individuales con MongoDB queries

Este resultado pone de relieve por sí solo el valor añadido que ofrecen las MongoDB queries. Incluso en nuestro pequeño ejemplo, el resultado tendrá largas cadenas de caracteres, lo que como mínimo dificultará mucho tu análisis si no dispones de otras herramientas. Por ello, a continuación, utilizaremos también el método find, pero especificando la búsqueda. Para ello, vamos a definir un requisito especial que debe cumplir un documento para figurar en los resultados. En nuestro ejemplo, buscamos todos los documentos cuyo nombre corresponda al valor “ATS”. Debe quedar de esta manera:

db.clientes.find (
    { "name" : "ATS" }
)

Las MongoDB queries simples de este tipo buscan ahora todos los documentos almacenados en la colección correspondiente y muestran las coincidencias con el valor de nombre “ATS”. En nuestra colección solo hay una entrada con este valor, por lo que el resultado quedará así:

db.clientes.find ( { "name" : "ATS" } )
{
    "_id" : ObjectID ( "673d14684o75iftbb0ct5003" ),
    "name" : "ATS",
    "units" : 17,
    "location" : "France",
    "transactions" : {
        "first" : {
            "year" : 2021,
        },
        "last" : {
            "year" : 2022,
        },
        "total" : 2
    }

También se puede hacer a la inversa. Si quieres mostrar todos los resultados excepto la entrada con “ATS”, escríbelo de la siguiente forma:

db.clientes.find (
    { "name" : { $ne : "ATS" } }
)

Si quieres generar MongoDB queries con diferentes valores, también puedes hacerlo con un array. En nuestro ejemplo, introducimos los clientes “ATS” y “Jorgensen”.

db.clientes.find (
    { "name" : [ $in : [ "ATS", "Jorgensen" ] } }
)

Consultar varios campos con MongoDB queries

Si necesitas resultados muy precisos, es importante acotar aún más la consulta. Para hacerlo, puedes especificar las MongoDB queries utilizando parámetros adicionales. Si ahora realizamos una consulta especificando el valor del segmento “units” (unidades), además del nombre de la empresa ”ATS”, se buscará un documento que contenga ambos valores:

db.clientes.find (
    { "name" : "ATS", "units" : 17 }
)

En este caso, se obtiene de nuevo una coincidencia exacta. Sin embargo, si uno de los dos valores no tiene coincidencias, no se obtendrá ningún resultado. Por ejemplo, esta entrada no tendría resultados:

db.clientes.find (
    { "name" : "ATS", "units" : 25 }
)

No obstante, si quieres utilizar MongoDB queries para tener en cuenta diferentes valores, pero quieres que la entrada se realice solo cuando se cumple al menos uno de los requisitos, introduce lo siguiente:

db.clientes.find (
    { $or : [ {"name" : "ATS"}, { "units" : 25 } ] }
)

Consultar valores en arrays

Los valores de las arrays también se pueden tener en cuenta con MongoDB queries. En nuestro caso, hay empresas que tienen filiales en varios países. Por ejemplo, puedes obtener todos los clientes que tienen al menos una filial en Alemania:

db.clientes.find (
    { "location" : "Germany" }
)

El resultado contiene ahora los tres clientes que tienen al menos una filial en Alemania. No obstante, si quieres ampliar la entrada y recuperar los clientes con filiales en Alemania y también en Austria, debes utilizar un array:

db.clientes.find (
    { "location" : [ "Germany", "Austria" ] }
)

Como puedes observar, solo se obtiene un resultado, aunque en teoría dos empresas coinciden con los criterios de búsqueda. Esto se debe a que MongoDB queries tiene en cuenta la entrada exacta y, por tanto, en este caso, el orden. No obstante, si quieres tomar valores que pueden estar en cualquier orden en un array, haz la consulta de esta manera:

db.clientes.find (
    { "location" : { $all : [ "Germany", "Austria" ] } }
)

MongoDB queries para documentos incrustados

En nuestro ejemplo, también hemos utilizado documentos incrustados (o documentos anidados). Estos también pueden aparecer en los resultados al utilizar MongoDB queries. Para ello, es necesario añadir un punto para indicarle a MongoDB que deben analizarse los campos de un documento incrustado. Por ejemplo, si necesitas una lista de los clientes que tienen más de diez transacciones de pedido, introduce lo siguiente:

db.clientes.find (
    { "transactions.total" : { $gt : 10 } }
)

MongoDB accede al documento “transactions” y, después, tiene en cuenta el número de transacciones de pedidos en “total”.

MongoDB queries: limitar el resultado

Incluso después de haber aprendido los métodos mencionados, es posible que los resultados obtenidos con MongoDB queries te parezcan muy extensos. Quizá quieras limitar entonces el resultado a unos pocos campos. Para ello se utilizan las denominadas proyecciones, que contienen el valor 1 (para campos incluidos) y 0 (para campos que deben excluirse). En el siguiente ejemplo, vamos a realizar una consulta en dos partes. En primer lugar, se inicia una búsqueda sin parámetros que contendría toda la información. Inmediatamente después, se realiza una proyección que solo tiene en cuenta el campo del nombre.

db.clientes.find (
    { }
    { "name" : 1 }
)

Así puedes obtener todos los datos, pero el resultado se limitará a los nombres correspondientes.

Utilizar cursores para optimizar el resultado

Los cursores son métodos que no controlan los resultados de MongoDB queries en sí, sino que personalizan su visualización. Por ejemplo, puedes limitar el número de resultados o cambiar su orden. Si solo deseas mostrar dos de los resultados, debes utilizar el método limit. Funciona así:

db.clientes.find (
    { }
    { "name" : 1 }
).limit ( 2 )

Con el siguiente comando puedes ordenar el resultado y obtener los tres clientes que menos productos han pedido:

db.clientes.find (
    { }
    { "name" : 1 }
).limit ( 2 ) .sort ( { "units" : 1 } )