Búsqueda de MongoDB usando Node.js

El operador $lookup es un operador de agregación o una etapa de agregación, que se utiliza para unir un documento de una colección a un documento de otra colección de la misma base de datos en función de algunas consultas. Ambas colecciones deben pertenecer a las mismas bases de datos.

La agregación en MongoDB es una operación que agrupa valores de varios documentos y puede realizar una variedad de operaciones en los datos agrupados para devolver un único resultado. Y $lookup es una de las operaciones que realiza la agregación.

¿Cómo funciona $búsqueda?

Tenemos dos colecciones, input collection (la colección sobre la que se realiza $lookup) y from collection (la colección de la que tomamos los documentos para unirlos a los documentos de la colección input).

$lookup toma los documentos seleccionados de la » colección de origen» en función de algunas consultas y luego los adjunta al documento de la «colección de entrada» en un campo de array separado. Es como una combinación externa izquierda de SQL.

Realice $búsqueda con Equality Match:

En la coincidencia de igualdad, para cada documento, el valor de cualquier campo específico del documento de recopilación de entrada se compara con el valor de cualquier campo específico de cada documento de recopilación de origen y, si coinciden, ese documento de recopilación de origen en particular se adjunta al documento de recopilación de entrada en un campo de array separado.

Sintaxis: $operador de búsqueda

{
    $lookup:
    {
        from: < "from collection" >,
        localField: < any field from "input collection" >,
        foreignField: < any field from "from collection" >,
        as: < attached array field >
    }
}

• de: Es el campo que contiene el nombre de “ de colección ”, de donde se van a tomar los documentos para unirlos a los documentos de la colección de entrada.
• localField: es cualquier campo de colección de entrada cuyo valor se va a comparar con el valor de outsideField.
• ForeignField: Es cualquier campo de la colección cuyo valor se va a comparar con el valor de localField.
• as: Es el campo de array en el que se almacenarán los documentos coincidentes de la colección .

Instalar mangosta:

Paso 1: puede visitar el enlace Instalar mongoose para instalar el módulo mongoose. Puede instalar este paquete usando este comando.

npm install mongoose

Paso 2: ahora puede importar el módulo mongoose en su archivo usando:

const mongoose = require('mongoose');

Base de datos: Ya hemos creado colecciones denominadas pedidos y clientes en nuestra base de datos GFG con las siguientes entradas que se muestran en la imagen a continuación:

Cobros pedidos y clientes en base de datos GFG

Creación de una aplicación de Node:

Paso 1: Cree package.json usando el siguiente comando:

npm init

Paso 2: cree el archivo model.js que contiene el esquema y el modelo para las colecciones de pedidos y clientes .

const mongoose = require('mongoose');
  
const orderSchema = new mongoose.Schema({
    _id: Number,
    customerId: Number,
    itemName: String
})
  
const customerSchema = new mongoose.Schema({
    _id: Number,
    name: String,
    city: String
})
  
const Order = new mongoose.model('order', orderSchema);
const Customer = new mongoose.model('customer', customerSchema);
  
module.exports = { Order, Customer };

Paso 3: Cree el archivo main.js con el siguiente código.

// Requiring module
const mongoose = require("mongoose");
  
// Importing Models Order and Customer from model.js
const { Customer, Order } = require("./model");
  
// Connecting to database
mongoose.connect("mongodb://localhost:27017/GFG", {
  useNewUrlParser: true,
  useUnifiedTopology: true,
  useFindAndModify: false,
});
  
// Implementing $lookup for customers collection
Customer.aggregate([
  {
    $lookup: {
      from: "orders",
      localField: "_id",
      foreignField: "customerId",
      as: "orders_info",
    },
  },
  // Deconstructs the array field from the
  // input document to output a document
  // for each element
  {
    $unwind: "$orders_info",
  },
])
  .then((result) => {
    console.log(result);
  })
  .catch((error) => {
    console.log(error);
  });

Ejecute main.js usando el comando:

node main.js

Explicación : aquí , el valor del campo _id de cada documento de recopilación de clientes se compara con el campo de ID de cliente de cada documento de recopilación de pedidos y, si coinciden, ese documento de recopilación de pedidos se adjunta al documento de recopilación de clientes en el campo de array orders_info .

Nota: Aquí $unwind se usa para deconstruir el campo de array «orders_info» del documento de entrada para generar un documento para cada elemento. Con esto podremos ver cada documento adjunto.

Salida : en la consola, obtenemos documentos de colección de entrada después de unirlos desde documentos de colección usando $búsqueda.

Salida después de ejecutar main.js

Cuando eliminemos el operador $unwind del código, obtendremos el resultado como se muestra a continuación:

Salida sin usar el operador $unwiind

Realización de $búsqueda con múltiples condiciones de unión:

Sintaxis: $operador de búsqueda

{
$búsqueda:
{
from: < “from collection” >,
let: { < var_1 >: < field_1 > , < var_2 >: < field_2 > , …… },
pipeline: < diferentes etapas del pipeline a realizar de “from” colección >,
como: < campo de array adjunto >
}
}

• de: Es el campo que contiene el nombre de “de colección” , de donde se van a tomar los documentos para unirlos a los documentos de la colección de entrada.
• let: Es un campo opcional. Pipeline no puede acceder directamente a los campos de documentos de «entrada» , por lo tanto, en let variable definimos nombres para los campos de documentos de entrada que se utilizarán en la tubería para realizar consultas.
• tubería: es el campo que ejecuta diferentes etapas de la tubería en los documentos de la colección «desde» y luego devuelve los documentos resultantes en el campo de array.
• as: Es el campo de array en el que se almacenarán los documentos coincidentes de la colección.

Nota:

• Para usar variables definidas en el campo $let, lo referenciamos como $$<variable>.
• Use el operador $expr dentro de $match para acceder a las variables $let field.

Cambie el archivo main.js como se indica a continuación y ejecútelo para obtener el resultado:

const mongoose = require("mongoose");
  
// Model for Order and Customer
const { Customer, Order } = require("./model");
  
// Connecting to database
mongoose.connect("mongodb://localhost:27017/GFG", {
  useNewUrlParser: true,
  useUnifiedTopology: true,
  useFindAndModify: false,
});
  
// Performing multiple query with the help of pipeline
Customer.aggregate([
  {
    $lookup: {
      from: "orders",
      let: { custId: "$_id" },
      pipeline: [
        {
          $match: {
            $expr: {
              $and: [
                { $eq: ["$customerId", "$$custId"] },
                { $eq: ["$itemName", "Watch"] },
              ],
            },
          },
        },
      ],
      as: "orders_info",
    },
  },
  {
    $unwind: "$orders_info",
  },
])
  .then((result) => {
    console.log(result);
  })
  .catch((error) => {
    console.log(error);
  });

Ejecute main.js usando el comando:

node main.js

Explicación: en el código anterior, estamos uniendo documentos de la colección de pedidos cuyo valor de customerId coincide con el valor de _id de la colección de clientes y cuyo valor de itemName es «Watch» . Para usar el campo _id de la colección de clientes en la canalización, lo hemos definido como custId en el campo let.

Nota: Aquí $unwind se usa para deconstruir el campo de array «orders_info» del documento de entrada para generar un documento para cada elemento. Con esto podremos ver cada documento adjunto.

Salida : en la consola, obtenemos documentos coincidentes como se muestra a continuación:

Salida después de ejecutar main.js

Cuando eliminemos el operador $unwind del código, obtendremos el resultado como se muestra a continuación:

Salida después de eliminar el operador $unwind