Proyectar campos de MongoDB

Introducción

En este laboratorio, aprenderá a usar la proyección de MongoDB para seleccionar y excluir campos específicos al consultar documentos. La proyección le permite controlar qué campos se devuelven en los resultados de su consulta, lo que le permite reducir la transferencia de datos innecesaria y mejorar el rendimiento de la consulta. Comenzará seleccionando campos de inclusión, luego pasará a especificar campos de exclusión, mezclando inclusión y exclusión, proyectando campos anidados y formateando campos de salida. Al final de este laboratorio, tendrá una sólida comprensión de cómo utilizar efectivamente la proyección en sus consultas de MongoDB.

Skills Graph

Seleccionar campos de inclusión

En este paso, aprenderá a usar la proyección de MongoDB para seleccionar campos específicos al consultar documentos. La proyección le permite controlar exactamente qué campos se devuelven en los resultados de su consulta.

Primero, iniciemos el shell de MongoDB y creemos una colección de muestra con la que trabajar:

mongosh

Una vez en el shell de MongoDB, cree una base de datos y agregue algunos documentos de usuario de muestra:

use projectlab_database

db.users.insertMany([
    {
        name: "John Doe",
        age: 30,
        email: "john.doe@example.com",
        city: "New York",
        job: "Software Engineer"
    },
    {
        name: "Jane Smith",
        age: 28,
        email: "jane.smith@example.com",
        city: "San Francisco",
        job: "Data Scientist"
    },
    {
        name: "Mike Johnson",
        age: 35,
        email: "mike.johnson@example.com",
        city: "Chicago",
        job: "Product Manager"
    }
])

Ahora, usemos la proyección para seleccionar solo campos específicos. Para incluir campos, use 1 en el documento de proyección:

db.users.find({}, { name: 1, age: 1, _id: 0 });

Salida de ejemplo:

[
  { name: 'John Doe', age: 30 },
  { name: 'Jane Smith', age: 28 },
  { name: 'Mike Johnson', age: 35 }
]

Analicemos la proyección:

• { name: 1, age: 1, _id: 0 } significa:
  • Incluir el campo name
  • Incluir el campo age
  • Excluir explícitamente el campo _id (por defecto, _id siempre se devuelve)

Al usar la proyección, puede controlar exactamente qué campos se devuelven en su consulta, lo que reduce la transferencia de datos innecesaria y mejora el rendimiento de la consulta.

Especificar campos de exclusión

En este paso, aprenderá a excluir campos específicos de los resultados de la consulta de MongoDB utilizando la proyección. Esta técnica le permite eliminar los campos no deseados de la salida del documento.

Continuaremos utilizando la colección users que creamos en el paso anterior. Para excluir campos, use 0 en el documento de proyección:

db.users.find({}, { email: 0, city: 0 });

Salida de ejemplo:

[
  {
    _id: ObjectId("..."),
    name: 'John Doe',
    age: 30,
    job: 'Software Engineer'
  },
  {
    _id: ObjectId("..."),
    name: 'Jane Smith',
    age: 28,
    job: 'Data Scientist'
  },
  {
    _id: ObjectId("..."),
    name: 'Mike Johnson',
    age: 35,
    job: 'Product Manager'
  }
]

Reglas importantes de proyección para recordar:

• No se puede mezclar inclusión y exclusión en la misma proyección (excepto para _id)
• _id es el único campo que se puede excluir explícitamente mientras se incluyen otros campos
• Usar 0 elimina los campos especificados del resultado de la consulta

Intentemos otro ejemplo excluyendo múltiples campos:

db.users.find({}, { email: 0, city: 0, _id: 0 });

Esta consulta devolverá documentos sin los campos email, ciudad y _id, mostrando solo nombre, edad y trabajo.

Mezclar inclusión y exclusión

En este paso, aprenderá sobre las reglas sutiles de mezclar inclusión y exclusión en las proyecciones de MongoDB. Si bien MongoDB generalmente no permite mezclar inclusión y exclusión en la misma proyección, hay una excepción especial para el campo _id.

Exploremos este concepto utilizando nuestra colección users existente:

Primero, probemos un ejemplo que demuestre la regla general:

// Esto causará un error
db.users.find({}, { name: 1, email: 0 });

Verá un mensaje de error que indica que no se puede mezclar proyecciones de inclusión y exclusión.

Sin embargo, _id es un caso especial. Puede incluir o excluir otros campos mientras gestiona explícitamente el campo _id:

db.users.find(
  {},
  {
    _id: 0, // Excluir _id
    name: 1, // Incluir name
    job: 1 // Incluir job
  }
);

Salida de ejemplo:

[
  { name: 'John Doe', job: 'Software Engineer' },
  { name: 'Jane Smith', job: 'Data Scientist' },
  { name: 'Mike Johnson', job: 'Product Manager' }
]

Intentemos otro ejemplo con una combinación diferente:

db.users.find(
  {},
  {
    _id: 0, // Excluir _id
    name: 1, // Incluir name
    age: 1, // Incluir age
    email: 0 // Esto normalmente causaría un error, pero la excepción de _id lo permite
  }
);

Conclusiones clave:

• No se puede mezclar inclusión y exclusión para campos regulares
• _id es el único campo que se puede incluir o excluir explícitamente cuando se proyectan otros campos
• Siempre sea explícito sobre qué campos desea incluir o excluir

Proyectar campos anidados

En este paso, aprenderá a proyectar campos anidados en documentos de MongoDB. Los campos anidados son campos dentro de documentos incrustados o matrices, lo que requiere un enfoque ligeramente diferente para la proyección.

Primero, actualicemos nuestra colección de usuarios con documentos más complejos y anidados:

// Borrar documentos existentes
db.users.deleteMany({});

// Insertar documentos con estructuras anidadas
db.users.insertMany([
  {
    name: "John Doe",
    contact: {
      email: "john.doe@example.com",
      phone: {
        mobile: "123-456-7890",
        work: "987-654-3210"
      }
    },
    skills: ["JavaScript", "MongoDB", "React"]
  },
  {
    name: "Jane Smith",
    contact: {
      email: "jane.smith@example.com",
      phone: {
        mobile: "234-567-8901",
        work: "876-543-2109"
      }
    },
    skills: ["Python", "Data Science", "Machine Learning"]
  }
]);

Para proyectar campos anidados, use notación de puntos:

// Proyectar campos anidados específicos
db.users.find(
  {},
  {
    name: 1,
    "contact.email": 1,
    "contact.phone.mobile": 1,
    _id: 0
  }
);

Salida de ejemplo:

[
  {
    name: 'John Doe',
    contact: {
      email: 'john.doe@example.com',
      phone: { mobile: '123-456-7890' }
    }
  },
  {
    name: 'Jane Smith',
    contact: {
      email: 'jane.smith@example.com',
      phone: { mobile: '234-567-8901' }
    }
  }
]

También puede proyectar campos de matriz:

// Proyectar las primeras dos habilidades
db.users.find(
  {},
  {
    name: 1,
    skills: { $slice: 2 },
    _id: 0
  }
);

Salida de ejemplo:

[
  {
    name: 'John Doe',
    skills: ['JavaScript', 'MongoDB']
  },
  {
    name: 'Jane Smith',
    skills: ['Python', 'Data Science']
  }
]

Puntos claves sobre la proyección de campos anidados:

• Use notación de puntos para acceder a campos anidados
• Puede proyectar campos anidados profundamente
• Para matrices, puede usar $slice para limitar el número de elementos devueltos

Formatear campos de salida

En este paso, aprenderá a formatear y transformar campos de salida utilizando las técnicas de proyección y agregación de MongoDB. Exploraremos maneras de renombrar, calcular y modificar campos durante la proyección.

Primero, actualicemos nuestra colección de usuarios con información más detallada:

// Borrar documentos existentes
db.users.deleteMany({});

// Insertar documentos con datos más complejos
db.users.insertMany([
  {
    name: "John Doe",
    age: 30,
    salary: 75000,
    department: "Engineering"
  },
  {
    name: "Jane Smith",
    age: 28,
    salary: 85000,
    department: "Data Science"
  },
  {
    name: "Mike Johnson",
    age: 35,
    salary: 95000,
    department: "Management"
  }
]);

Utilice el operador $ para renombrar campos durante la proyección:

db.users.find(
  {},
  {
    fullName: "$name",
    yearsOld: "$age",
    annualSalary: "$salary",
    _id: 0
  }
);

Salida de ejemplo:

[
  { fullName: 'John Doe', yearsOld: 30, annualSalary: 75000 },
  { fullName: 'Jane Smith', yearsOld: 28, annualSalary: 85000 },
  { fullName: 'Mike Johnson', yearsOld: 35, annualSalary: 95000 }
]

También puede realizar cálculos utilizando los operadores de agregación $:

db.users.aggregate([
  {
    $project: {
      name: 1,
      monthlySalary: { $divide: ["$salary", 12] },
      salaryTier: {
        $switch: {
          branches: [
            { case: { $lt: ["$salary", 80000] }, then: "Junior" },
            { case: { $gte: ["$salary", 80000] }, then: "Senior" }
          ],
          default: "Unknown"
        }
      },
      _id: 0
    }
  }
]);

Salida de ejemplo:

[
  {
    name: 'John Doe',
    monthlySalary: 6250,
    salaryTier: 'Junior'
  },
  {
    name: 'Jane Smith',
    monthlySalary: 7083.333333333333,
    salaryTier: 'Senior'
  },
  {
    name: 'Mike Johnson',
    monthlySalary: 7916.666666666667,
    salaryTier: 'Senior'
  }
]

Puntos claves sobre el formateo de campos de salida:

• Utilice $ para renombrar campos durante la proyección
• La canalización de agregación permite transformaciones complejas de campos
• Puede realizar cálculos y crear campos condicionales
• La etapa $project es poderosa para el formateo de campos

Resumen

En este laboratorio, aprenderá a utilizar la característica de proyección de MongoDB para seleccionar o excluir campos específicos al consultar documentos. Comenzará por incluir solo los campos que necesita, luego explorará la exclusión de campos no deseados y, finalmente, mezclará inclusión y exclusión para personalizar la salida. Además, aprenderá a proyectar campos anidados y formatear la salida. Estas técnicas le permiten controlar los datos devueltos por sus consultas, mejorando el rendimiento y reduciendo la transferencia de datos innecesaria.