Usar los tipos básicos de MongoDB

Introducción

En este laboratorio, aprenderá a trabajar con varios tipos de datos en MongoDB, incluyendo números, cadenas, booleanos, fechas e IDs de objeto. El laboratorio aborda ejemplos prácticos de cómo almacenar, consultar y manipular datos de diferentes tipos en su base de datos MongoDB. Adquirirá experiencia práctica al realizar operaciones comunes y comprender los casos de uso adecuados para cada tipo de datos.

El laboratorio se divide en cinco pasos principales: trabajar con números, manejar datos de cadena, usar valores booleanos, almacenar fechas y horas y administrar IDs de objeto. Cada paso ofrece una demostración detallada, mostrando los comandos de MongoDB correspondientes y los rasgos y aplicaciones únicas de cada tipo de datos.

Skills Graph

Trabajar con números

En este paso, aprenderá a trabajar con los tipos de datos numéricos en MongoDB, explorando diferentes maneras de almacenar y manipular números en su base de datos.

Comprendiendo los tipos numéricos en MongoDB

MongoDB admite varios tipos de datos numéricos, incluyendo enteros y números de punto flotante. Comencemos lanzando la shell de MongoDB y explorando estos tipos.

Primero, abra su terminal y inicie la shell de MongoDB:

mongosh

Ahora, creemos una base de datos y una colección para demostrar las operaciones numéricas:

use numbers_lab
db.createCollection("products")

Insertando números enteros y decimales

Agregemos algunos productos con diferentes tipos numéricos:

db.products.insertMany([
    {
        name: "Laptop",
        price: 999,           // Entero
        stock: 50,            // Entero
        discount: 0.1,        // Decimal
        rating: 4.5           // Número de punto flotante
    },
    {
        name: "Smartphone",
        price: 599,
        stock: 100,
        discount: 0.15,
        rating: 4.7
    }
])

Salida de ejemplo

{
  acknowledged: true,
  insertedIds: {
    '0': ObjectId("..."),
    '1': ObjectId("...")
  }
}

Operaciones numéricas

MongoDB le permite realizar varias operaciones numéricas. Demostremos algunas:

// Encuentre los productos con un precio mayor a 500
db.products.find({ price: { $gt: 500 } })

// Actualice el stock con incremento
db.products.updateOne(
    { name: "Laptop" },
    { $inc: { stock: 10 } }
)

// Encuentre los productos con una calificación superior a 4
db.products.find({ rating: { $gte: 4 } })

Puntos claves para recordar

• Los enteros son números enteros sin puntos decimales
• Los números de punto flotante pueden tener decimales
• MongoDB utiliza $gt (mayor que), $lt (menor que), $inc (incremento) para las operaciones numéricas

Manejar datos de cadena

En este paso, aprenderá a trabajar con los tipos de datos de cadena en MongoDB, explorando diferentes maneras de almacenar, consultar y manipular datos de texto en su base de datos.

Comprendiendo los tipos de cadena en MongoDB

MongoDB ofrece potentes capacidades de manipulación de cadenas. Continuaremos utilizando la base de datos que creamos en el paso anterior para demostrar las operaciones de cadena.

Primero, asegúrese de estar en la shell de MongoDB:

mongosh

Cambie a la base de datos existente:

use numbers_lab

Insertando y consultando datos de cadena

Agregemos más documentos con campos de cadena:

db.products.insertMany([
    {
        name: "Wireless Headphones",
        brand: "TechSound",
        description: "High-quality noise-canceling headphones",
        color: "Black",
        tags: ["electronics", "audio", "wireless"]
    },
    {
        name: "Smart Watch",
        brand: "FitTech",
        description: "Advanced fitness tracking smartwatch",
        color: "Silver",
        tags: ["wearables", "fitness", "technology"]
    }
])

Operaciones de consulta de cadena

MongoDB ofrece varias maneras de consultar datos de cadena:

// Encuentre los productos por nombre exacto
db.products.find({ name: "Smart Watch" })

// Búsqueda sin distinción de mayúsculas y minúsculas utilizando regex
db.products.find({ brand: { $regex: /tech/i } })

// Buscar en el array de etiquetas
db.products.find({ tags: "electronics" })

Métodos de manipulación de cadenas

También puede realizar operaciones de cadena:

// Actualizar descripción
db.products.updateOne(
    { name: "Wireless Headphones" },
    { $set: { description: description.toUpperCase() } }
)

// Verificar la longitud de la cadena
db.products.find({
    $expr: { $gt: [{ $strLenCP: "$name" }, 10] }
})

Puntos claves para recordar

• Las cadenas en MongoDB están codificadas en UTF-8
• Use $regex para la coincidencia de patrones
• Los arrays pueden contener elementos de cadena
• MongoDB admite varios métodos de manipulación de cadenas

Usar valores booleanos

En este paso, aprenderá a trabajar con los tipos de datos booleanos en MongoDB, explorando cómo almacenar, consultar y usar valores de verdadero/falso en su base de datos.

Comprendiendo los tipos booleanos en MongoDB

Los valores booleanos son cruciales para representar condiciones de verdadero/falso en sus datos. Continuaremos utilizando nuestra base de datos existente para demostrar las operaciones booleanas.

Primero, asegúrese de estar en la shell de MongoDB:

mongosh

Cambie a la base de datos existente:

use numbers_lab

Insertando documentos con campos booleanos

Agregemos productos con atributos booleanos:

db.products.insertMany([
    {
        name: "Premium Bluetooth Speaker",
        isWireless: true,
        isInStock: true,
        hasBluetooth: true,
        supportsBattery: true
    },
    {
        name: "Wired Gaming Headset",
        isWireless: false,
        isInStock: false,
        hasBluetooth: false,
        supportsBattery: false
    }
])

Operaciones de consulta booleana

MongoDB ofrece maneras poderosas de consultar campos booleanos:

// Encuentre los productos inalámbricos
db.products.find({ isWireless: true })

// Encuentre los productos que no están en stock
db.products.find({ isInStock: false })

// Consultas booleanas complejas
db.products.find({
    $and: [
        { isWireless: true },
        { hasBluetooth: true }
    ]
})

Actualizando valores booleanos

Puede actualizar fácilmente los campos booleanos:

// Actualizar el estado de stock
db.products.updateOne(
    { name: "Wired Gaming Headset" },
    { $set: { isInStock: true } }
)

// Cambiar el valor de un booleano
db.products.updateOne(
    { name: "Premium Bluetooth Speaker" },
    { $not: { isWireless: true } }
)

Puntos claves para recordar

• Los valores booleanos son true o false
• Use operadores lógicos como $and, $or para consultas complejas
• Los campos booleanos son útiles para banderas y seguimiento de estado
• MongoDB trata los campos booleanos como cualquier otro tipo de datos

Almacenar fecha y hora

En este paso, aprenderá a trabajar con los tipos de datos de fecha y hora en MongoDB, explorando diversas maneras de almacenar, consultar y manipular datos temporales.

Comprendiendo los tipos de fecha en MongoDB

MongoDB ofrece potentes capacidades de manejo de fechas y horas. Continuaremos utilizando nuestra base de datos existente para demostrar las operaciones de fecha.

Primero, asegúrese de estar en la shell de MongoDB:

mongosh

Cambie a la base de datos existente:

use numbers_lab

Insertando documentos con campos de fecha

Agregemos productos con diferentes campos relacionados con la fecha:

db.products.insertMany([
    {
        name: "Laptop Pro",
        releaseDate: new Date(),
        lastUpdated: new Date(),
        warrantyExpiration: new Date("2025-12-31"),
        manufacturingDate: new Date("2023-01-15")
    },
    {
        name: "Smartphone Elite",
        releaseDate: new Date("2023-06-01"),
        lastUpdated: new Date(),
        warrantyExpiration: new Date("2024-06-01"),
        manufacturingDate: new Date("2023-05-15")
    }
])

Operaciones de consulta de fecha

MongoDB ofrece sofisticadas capacidades de consulta de fecha:

// Encuentre los productos lanzados después de una fecha específica
db.products.find({
    releaseDate: { $gt: new Date("2023-01-01") }
})

// Encuentre los productos con la garantía expirando en el próximo año
db.products.find({
    warrantyExpiration: {
        $gte: new Date(),
        $lt: new Date(new Date().setFullYear(new Date().getFullYear() + 1))
    }
})

// Obtenga los productos fabricados en un mes específico
db.products.find({
    $expr: {
        $eq: [{ $month: "$manufacturingDate" }, 5]
    }
})

Métodos de manipulación de fechas

Puede realizar varias operaciones relacionadas con la fecha:

// Actualizar la fecha de última actualización
db.products.updateOne(
    { name: "Laptop Pro" },
    { $currentDate: { lastUpdated: true } }
)

// Agregar días a una fecha
db.products.updateOne(
    { name: "Smartphone Elite" },
    {
        $set: {
            extendedWarranty: new Date(
                new Date("2024-06-01").setDate(
                    new Date("2024-06-01").getDate() + 30
                )
            )
        }
    }
)

Puntos claves para recordar

• MongoDB almacena fechas como objetos de fecha completos
• Use new Date() para crear la marca de tiempo actual
• Compare fechas utilizando operadores de comparación
• MongoDB proporciona métodos para extraer componentes de fecha
• Las fechas se almacenan en UTC por defecto

Administrar ObjectIds

En este paso, aprenderá sobre los ObjectIds en MongoDB, comprendiendo cómo funcionan como identificadores únicos y cómo manipularlos en su base de datos.

Comprendiendo los ObjectIds en MongoDB

Los ObjectIds son identificadores especiales generados automáticamente por MongoDB para cada documento. Exploraremos sus características y uso.

Primero, asegúrese de estar en la shell de MongoDB:

mongosh

Cambie a la base de datos existente:

use numbers_lab

Creando y examinando ObjectIds

Vamos a insertar documentos y examinar sus identificadores únicos:

// Inserta un documento y observa su ObjectId
db.users.insertOne({
    username: "johndoe",
    email: "[email protected]",
    registrationDate: new Date()
})

// Recupera el documento insertado
const newUser = db.users.findOne({ username: "johndoe" })

Propiedades y métodos de ObjectId

Los ObjectIds contienen varias propiedades interesantes:

// Obtiene la marca de tiempo del ObjectId
const timestamp = newUser._id.getTimestamp()
print("Documento creado en:", timestamp)

// Genera un nuevo ObjectId
const customId = new ObjectId()
print("ObjectId personalizado:", customId)

Trabajando con ObjectIds en consultas

Puede usar ObjectIds para la recuperación precisa de documentos:

// Encuentra el documento por su ObjectId exacto
db.users.findOne({ _id: newUser._id })

// Verifica si un ObjectId es válido
const isValid = ObjectId.isValid(newUser._id)
print("¿Es el ObjectId válido?", isValid)

Operaciones avanzadas de ObjectId

MongoDB proporciona métodos para extraer y manipular ObjectIds:

// Compara ObjectIds
const anotherUser = db.users.insertOne({
    username: "janedoe",
    email: "[email protected]"
})

// Verifica si un ObjectId es menor que otro
const isEarlier = newUser._id < anotherUser.insertedId
print("¿Es el ID del primer usuario más antiguo?", isEarlier)

Puntos claves para recordar

• Los ObjectIds son identificadores únicos de 12 bytes
• Contienen una marca de tiempo, un identificador de máquina, un ID de proceso y un valor aleatorio
• Cada documento obtiene un ObjectId automático si no se especifica
• Los ObjectIds se pueden usar para la clasificación y el seguimiento del tiempo de creación de documentos

Resumen

En este laboratorio, aprendiste a trabajar con diferentes tipos de datos numéricos en MongoDB, incluyendo enteros y números de punto flotante. Exploraste formas de insertar, consultar y actualizar datos numéricos, utilizando operadores como $gt, $lt y $inc. Además, adquiriste una comprensión de cómo manejar datos de cadena, trabajar con valores booleanos, almacenar información de fecha y hora y administrar ObjectIds en tu base de datos de MongoDB.

También aprendiste cómo realizar varias operaciones de cadena, como consultar, actualizar y manipular datos de texto. El laboratorio cubrió el uso de diferentes operadores y métodos relacionados con cadenas proporcionados por MongoDB para trabajar efectivamente con información textual en tus aplicaciones.