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 es­tru­c­tu­ra del método es muy lógica y permite utilizar pa­rá­me­tros para acotar las consultas.

Búsqueda eficaz en co­le­c­cio­nes

MongoDB es una solución NoSQL do­cu­me­n­tal con la que se pueden almacenar y gestionar fá­ci­l­me­n­te ca­n­ti­da­des de datos grandes y diversas. El sistema gestor de bases de datos es muy flexible y tiene una sencilla es­ca­la­bi­li­dad ho­ri­zo­n­tal.

A di­fe­re­n­cia de las bases de datos re­la­cio­na­les, en este caso los datos se almacenan en do­cu­me­n­tos BSON (JSON binario) y se agrupan en co­le­c­cio­nes. No obstante, para que esto ocurra, se requieren potentes me­ca­ni­s­mos de consulta que puedan filtrar la base de datos y solo presenten la in­fo­r­ma­ción que se necesita. Estas consultas de MongoDB buscan incluso en co­le­c­cio­nes complejas y pro­po­r­cio­nan la in­fo­r­ma­ción que se busca.

¿Qué son las consultas de MongoDB?

MongoDB queries es una he­rra­mie­n­ta intuitiva que sirve para buscar en es­tru­c­tu­ras 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 re­su­l­ta­dos. Esto es es­pe­cia­l­me­n­te im­po­r­ta­n­te, ya que MongoDB permite almacenar muchos tipos di­fe­re­n­tes de datos y, de no existir las opciones de filtrado ne­ce­sa­rias, sería difícil gestionar una base de datos. A co­n­ti­nua­ción, ex­pli­ca­mos paso a paso cómo crear fá­ci­l­me­n­te queries en MongoDB y cómo uti­li­zar­las.

¿Qué re­qui­si­tos hay que cumplir para usar las MongoDB queries?

Para utilizar las MongoDB queries, solo son ne­ce­sa­rios algunos re­qui­si­tos.

1. Primero, debes instalar MongoDB en tu ordenador. La base de datos funciona en muchos sistemas ope­ra­ti­vos, por lo que puedes seguir estas in­s­tru­c­cio­nes con Linux, OS X o Windows. Los pasos po­s­te­rio­res a la in­s­ta­la­ció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 in­s­ta­la­ción.
2. Para utilizar la función de búsqueda deben tenerse derechos de ad­mi­ni­s­tra­dor.
3. Lo mejor es crear un entorno de prueba para utilizar por primera vez el método sin riesgos. A co­n­ti­nua­ción, te ex­pli­ca­mos qué pasos seguir.

Es­tru­c­tu­ra de una colección de prueba

Primero, abre la Shell e inicia sesión con tus datos de ad­mi­ni­s­tra­dor. A co­n­ti­nua­ció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 do­cu­me­n­tos simples, sino también arrays, varios campos y do­cu­me­n­tos in­cru­s­ta­dos. 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 in­fo­r­ma­ció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.
• tra­nsac­tio­ns: 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 tra­n­sac­ción contiene in­fo­r­ma­ció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 do­cu­me­n­tos adi­cio­na­les se han incluido para poder añadir más in­fo­r­ma­ción con po­s­te­rio­ri­dad. Así los datos siguen estando or­ga­ni­za­dos.

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 or­ga­ni­za­ción. Si más adelante quisieras utilizar MongoDB queries de forma pro­fe­sio­nal, podrías crear co­le­c­cio­nes mucho más extensas mediante el método in­se­r­t­Ma­ny. 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 ga­ra­n­ti­zan que cada documento pueda en­co­n­trar­se también a través del ID. Si quieres ase­gu­rar­te de que todos los do­cu­me­n­tos se han tra­n­s­fe­ri­do a la colección, puedes utilizar MongoDB find en lugar de seguir in­tro­du­cie­n­do pa­rá­me­tros adi­cio­na­les:

db.clientes.find ( )

Como resultado se obtiene un listado de todos los Object ID con los do­cu­me­n­tos completos, que ahora podrás explorar con MongoDB queries.

Consultar campos in­di­vi­dua­les 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 ca­ra­c­te­res, lo que como mínimo di­fi­cu­l­ta­rá mucho tu análisis si no dispones de otras he­rra­mie­n­tas. Por ello, a co­n­ti­nua­ción, uti­li­za­re­mos también el método find, pero es­pe­ci­fi­ca­n­do la búsqueda. Para ello, vamos a definir un requisito especial que debe cumplir un documento para figurar en los re­su­l­ta­dos. En nuestro ejemplo, buscamos todos los do­cu­me­n­tos cuyo nombre co­rre­s­po­n­da al valor “ATS”. Debe quedar de esta manera:

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

Las MongoDB queries simples de este tipo buscan ahora todos los do­cu­me­n­tos al­ma­ce­na­dos en la colección co­rre­s­po­n­die­n­te y muestran las coin­ci­de­n­cias 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 re­su­l­ta­dos excepto la entrada con “ATS”, escríbelo de la siguiente forma:

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

Si quieres generar MongoDB queries con di­fe­re­n­tes valores, también puedes hacerlo con un array. En nuestro ejemplo, in­tro­du­ci­mos los clientes “ATS” y “Jorgensen”.

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

Consultar varios campos con MongoDB queries

Si necesitas re­su­l­ta­dos muy precisos, es im­po­r­ta­n­te acotar aún más la consulta. Para hacerlo, puedes es­pe­ci­fi­car las MongoDB queries uti­li­za­n­do pa­rá­me­tros adi­cio­na­les. Si ahora rea­li­za­mos una consulta es­pe­ci­fi­ca­n­do 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 coin­ci­de­n­cia exacta. Sin embargo, si uno de los dos valores no tiene coin­ci­de­n­cias, no se obtendrá ningún resultado. Por ejemplo, esta entrada no tendría re­su­l­ta­dos:

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

No obstante, si quieres utilizar MongoDB queries para tener en cuenta di­fe­re­n­tes valores, pero quieres que la entrada se realice solo cuando se cumple al menos uno de los re­qui­si­tos, 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 do­cu­me­n­tos in­cru­s­ta­dos

En nuestro ejemplo, también hemos utilizado do­cu­me­n­tos in­cru­s­ta­dos (o do­cu­me­n­tos anidados). Estos también pueden aparecer en los re­su­l­ta­dos al utilizar MongoDB queries. Para ello, es necesario añadir un punto para indicarle a MongoDB que deben ana­li­zar­se los campos de un documento in­cru­s­ta­do. Por ejemplo, si necesitas una lista de los clientes que tienen más de diez tra­n­sac­cio­nes de pedido, introduce lo siguiente:

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

MongoDB accede al documento “tra­nsac­tio­ns” y, después, tiene en cuenta el número de tra­n­sac­cio­nes de pedidos en “total”.

MongoDB queries: limitar el resultado

Incluso después de haber aprendido los métodos me­n­cio­na­dos, es posible que los re­su­l­ta­dos obtenidos con MongoDB queries te parezcan muy extensos. Quizá quieras limitar entonces el resultado a unos pocos campos. Para ello se utilizan las de­no­mi­na­das pro­ye­c­cio­nes, 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 pa­rá­me­tros que co­n­te­n­dría toda la in­fo­r­ma­ción. In­me­dia­ta­me­n­te después, se realiza una pro­ye­c­ció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 co­rre­s­po­n­die­n­tes.

Utilizar cursores para optimizar el resultado

Los cursores son métodos que no controlan los re­su­l­ta­dos de MongoDB queries en sí, sino que pe­r­so­na­li­zan su vi­sua­li­za­ción. Por ejemplo, puedes limitar el número de re­su­l­ta­dos o cambiar su orden. Si solo deseas mostrar dos de los re­su­l­ta­dos, 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 } )