Operaciones CRUD desde la consola de MongoDB

![](

Comparison Query Operators
$eq -> Matches values that are equal to a specified value.
$gt -> Matches values that are greater than a specified value.
$gte -> Matches values that are greater than or equal to a specified value.
$in -> Matches any of the values specified in an array.
$lt -> Matches values that are less than a specified value.
$lte -> Matches values that are less than or equal to a specified value.
$ne -> Matches all values that are not equal to a specified value.
$nin -> Matches none of the values specified in an array.

Para los que quieran solo copiar y pegar

db.inventory.insertOne( {_id:"soyID", item: "canvas", qty: 100, tags: ["cotton"], size: { h: 28, w: 35.5, uom: "cm"} } )```

Les dejo un tutorial donde explico algunas cosas extras de las operaciones CRUD en Mongo cosas básicas de un CRUD en MongoDB

No te olvides de poner el filter en el deleteMany(). (NoSQL)
No te olvides de poner el where en el delete from. (SQL)

Apuntes de la clase
InsertOne(). Guardar un documento dentro de la colección en la BD. Si no existe la conexión MONGODB la crea. Ingresa en formato JSON. Al hacer un insert dentro de una colección sino especifica el underscoreId (es un campo obligatorio que la BD pide) Mongo lo crea automáticamente.

InsertMany() recibe un arreglo en formato JSON y los ingresa a MongoDB automáticamente MongoDB tiene automicidad dentro de los documentos quiere decir que en el las operaciones de escritura garantiza que al escribir un documento la operación es atómica (se escribe y si no se escribe se hace rollback ( no se guarda en la BD)).

Find({CONDICION}). Se hace una consulta con un filtro y nos permite buscar uno o varios documentos que cumplan la condición.

FindOne(). Devuelve los documentos en orden natural (guarda los doc. dentro del sistema de archivos), se pueden definir conforme los índices. FinOne({_id: objectId(‘EL ID DEL OBJETO’)}).

Operador AND la forma sencilla es ponerla dentro del filtro FinOne({_id: objectId(‘EL ID DEL OBJETO’), qty: {$slte: 75} }). Si y solo si ambas son verdaderas devuelve un documento.

**UpdateOne(Filtro, nuevo valor). **De igual manera recibe un JSON o un arreglo de doc. UpdateOne({_id: objectId(‘ID DEL OBJETO’)}, {$set: {qty:130}}). updataMany() si hay más de un doc. Que cumplan con la condición cambiará el valor de cada uno

DeleteOne() hace el paso del filtro, borrará según su orden natural que encuentre con el filtro.
DeleteOne({status: “A”})

DeleteMany(). Compara el filtro con la cantidad de doc. Que cuplen con el filtro y los borra
DeleteOne({status: “A”})

db.inventory.insertMany( [
   { item: "canvas", qty: 100, size: { h: 28, w: 35.5, uom: "cm" }, status: "A" },
   { item: "journal", qty: 25, size: { h: 14, w: 21, uom: "cm" }, status: "A" },
   { item: "mat", qty: 85, size: { h: 27.9, w: 35.5, uom: "cm" }, status: "A" },
   { item: "mousepad", qty: 25, size: { h: 19, w: 22.85, uom: "cm" }, status: "P" },
   { item: "notebook", qty: 50, size: { h: 8.5, w: 11, uom: "in" }, status: "P" },
   { item: "paper", qty: 100, size: { h: 8.5, w: 11, uom: "in" }, status: "D" },
   { item: "planner", qty: 75, size: { h: 22.85, w: 30, uom: "cm" }, status: "D" },
   { item: "postcard", qty: 45, size: { h: 10, w: 15.25, uom: "cm" }, status: "A" },
   { item: "sketchbook", qty: 80, size: { h: 14, w: 21, uom: "cm" }, status: "A" },
   { item: "sketch pad", qty: 95, size: { h: 22.85, w: 30.5, uom: "cm" }, status: "A" }
] )


db.inventory.find( { item: "canvas" } )


db.inventory.insertOne(
   { _id: "one", item: "canvas", qty: 100, tags: ["cotton"], size: { h: 28, w: 35.5, uom: "cm" } }
)```

Encontre que el update() no actualiza todos los documentos si no tiene activa la opcion de multi, si quieren actualizar todo lo que empate con el filtro por defecto se puede usar el metodo updateMany()

db.inventory.update(
    { qty: { $eq: 10 } },
    { $set: { qty: 40 } },
    { multi: true }
)

// O se puede usar

db.inventory.updateMany(
    { qty: { $eq: 10 } },
    { $set: { qty: 40 } }
)

en el método findOne puedes pasar solamente el valor del object id

db.inventory.findOne('5c9bcbdfb8a58f18905f89d3')

pero si utilizas un filtro si debes pasarlo como ObjectId o te regresará null

db.inventory.findOne({_id: ObjectId('5c9bcbdfb8a58f18905f89d3')})

también, si almacenaste tu id como string y no como object id

db.inventory.insertOne(_id: 'qwerty', item: 'canvas')

y lo intentas consultar sólo con el id

db.inventory.findOne('qwerty')

te dará el error

Error: error: {
“ok” : 0,
“errmsg” : “ReferenceError: qwerty is not defined :\[email protected]:1:15\n”,
“code” : 139,
“codeName” : “JSInterpreterFailure”
}

JSON usado por el profesor en el método insertOne():

db.inventory.insertOne({ item: "canvas", qty: 100, tags:["cotton"], size: {h:28, w:35.5, uom: "cm"}})

Importante tener en cuenta que si nosotros mismos definimos los _id, para la consulta no es necesario agregar el método ObjectId(), Por ejemplo:

db.inventory.findOne({_id: "soy id"})

antes de esta clase esperaba ver un ejemplo de como diseñar desde cero el model de una base de datos utilizando mongoDB

Buenísimo el resumen y descripción del profesor en el vídeo!

Hola tengo una duda y como se podria actualizar un array dentro de un documento pq tengo el siguiente documento con la siguiente estructura y no se como agregarle un item al array

"category": "Other",
 "phone": " 052050000 - 0999991097",	
 "visited": [
            {
                "ref": "5d67dd8a095e3f47d4f9c929",
                "child": [
                    {
                        "id": "5d67dd8376bb0247bf3a70ff"
                    }
                ]
            }
        ]

y quiero agregarle un child al ref pero no se como se hace el update, aquien que sepa q me pueda decir, soy nuevo con mongo y no le entiendo bien esto de actualizar, pq actualizar puede ser cambiar un valor o agregar un valor o eliminar un valor de un documento

db.inventory.insertMany([
   { item: "journal", qty: 25, size: { h: 14, w: 21, uom: "cm" }, status: "A" },
   { item: "notebook", qty: 50, size: { h: 8.5, w: 11, uom: "in" }, status: "A" },
   { item: "paper", qty: 100, size: { h: 8.5, w: 11, uom: "in" }, status: "D" },
   { item: "planner", qty: 75, size: { h: 22.85, w: 30, uom: "cm" }, status: "D" },
   { item: "postcard", qty: 45, size: { h: 10, w: 15.25, uom: "cm" }, status: "A" }
]);

Encontré esta lista por Internet ❤️
$eq: igual que (equal)
$ne: distinto de (not equal)
$gt: valores mayores que (greater than)
$gte: valores mayores o iguales que (greater than or equal)
$lt: valores menores que (lower than)
$lte: valores menores o iguales que (lower than or equal)
$in: sus valores se encuentran dentro del array especificado. Por ejemplo: { “pais”: { $in: [“España”, “Francia”] }} mostrará todos los documentos cuyo campo pais sea España o Francia
$nin: operación contraria a $in, obtiene los documentos cuyo valor NO esté en el array

Con windows usamos CMD
y desde la ubicacion:
C:\Program Files\MongoDB\Server\4.2\bin
corremos:
mongo mongodb+srv://<user>:<password>@cluster0.adj3o.mongodb.net

eso es todo

En **mongoDB ** todo elemento que se inserta en un documento si este no contiene un _id es agregado al objeto automáticamente. Sin embargo, es posible definir tu propio _id pero este debe ser único y no haber sido usado anteriormente en el mismo documento.

En mongo los _id autogenerados siempre seran unicos.

No me puedo conectar a mongoBD Atlas desde el shell, alguien tiene la solución? (soy usuario windows).

Excelente Clase

que bueno y facil de usar. lo malo es que como es tan facil como en el caso del delete la gente puede hacer un truncate de la coleccion muy facilmente.

Insertar db.inventory.insertOne({ item: “canvas”, qty: 100, tags: [“cotton”], size: { h: 28, w: 35.5, uom: “cm”} })

Pregunta de examen:
¿Qué ocurre si ejecuto db.collection.deleteMany({})?

Insertar documentos desde la consola de Mongo

El CRUD describe las funciones elementales de una base de datos persistente. CRUD significa Crear, Recuperar/Leer, Actualizar y Eliminar.

Operaciones de crear e insertar nuevos documentos a una colección. Si la colección no existe actualmente, las operaciones de inserción crearán la colección.

MongoDB proporciona los siguientes métodos para insertar documentos en una colección:

db.<collection>.insert({JSON-Document}) Permite agregar una o varias colecciones a una base de datos.
 db.<collection>.insertOne({JSON-Document}) A diferencia del insert({JSON-Document}), este método solo inserta una colección.
 db.<collection>.insertMany([{JSON-Document}, {Other-JSON-Document}, {...}]) Este método es similar a insert({JSON-Document}), sin embargo, este método fue incluido en la versión 3 de MongoDB por ende debe comenzar a usarse y evitar insert({JSON-Document}).

Funciones find y findOne

Las operaciones de lectura, recuperan documentos de una colección. MongoDB proporciona los siguientes métodos para leer documentos de una colección:

    db.<collection>.find() Imprime los primeros 20 documentos que encuentra.
        .limit(n) Imprime los primeros n documentos que encuentra.
        .pretty() Imprime los documentos de una forma más legible.
    db.<collection>.find({"clave": "valor"}, {"clave": valor}) Imprime el documento que contenga la(s) clave(s) y el (o los) valor(es) especificado(s). Con findOne({...}) se muestran los documentos de forma más legibles para la vista.
    db.<collection>.find({"clave": {$gt: "valor"}}) Imprime los documentos mayores al valor de alguna clave en un documento.
        $gt Significa mayor que (>).
        $lt Significa menor que (<).
        $gte Significa mayor o igual a (>=).
        $lte Significa menor o igual a (<=).
    db.<collection>.findOne() Imprime solo el primer documentos que encuentra.

Modificación de documentos en la consola de MongoDB

Las operaciones de actualización, modifican los documentos existentes en una colección. MongoDB proporciona los siguientes métodos para actualizar documentos de una colección:

db.<collection>.save({JSON-Document)} Modifica un campo si se encuentra en una colección, si no se agrega.
 db.<collection>.update({JSON-Document)} Actualiza el documento por completo, es decir, elimina todos los campos y agrega los nuevos dejando así solo el _id.
 db.<collection>.updateOne({filtro}, {"clave": "valor"}) Se actualizará el primer documento que coincida con el filtro.
 db.<collection>.updateMany({filtro}, {"clave": "valor"}) Se actualizará todos los documentos que coincida con el filtro.

Eliminar documentos en la consola de MongoDB

Las operaciones de borrado, eliminan documentos de una colección. MongoDB proporciona los siguientes métodos para eliminar documentos de una colección:

    db.<collection>.deleteOne({"filter")} Elimina el primer documento encontrado según el filtro.
    db.<collection>.deleteMany({"filter")} Elimina todos los documentos encontrados según el filtro.
    db.<collection>.remove({"filter")} Elimina un campo según el filtro, es decir, si coincide uno o muchos documentos con el filtro serán eliminados de la base de datos.
    db.<collection>.drop() Elimina todos los documentos de una colección.

Dato extra

Para crear solamente la colección sin registros podemos utilizar:

db.createCollection("nombre")

y comprobamos con show collections

Para eliminar toda una colección es lo siguiente

db.nombredemicoleccion.drop()

⚠️Mucho cuidado al eliminar cosas⚠️

Wow me parece super comodo lo de los idObject automaticos

Me sorprende lo que tarda en ejecutarse las consultas la server, tardan como 9 segundos con mi conexion de internet

😦 …

Los operadores de Mongo estan loquisimos. Ni parecidos a los de SQL

Se me hace incomodo usar la consola por la propia sintaxis de MongoDB.

Create

db.**<collection>**.insertOne({BSON})

Recibe un elemento que sera agregado a la colección

db.<collection>.insertMany([{ ... }, { ... }]).

Recibe un array de BSON y devuelve todos los IDs de los elementos que se crearon correctamente.

Read

db.collection.find({<Conditions>})

Recibe un bson, Regresa todos los documentos que cumplan con las condiciones dadas en el json

db.collection.findOne({<conditions>})

Retorna el primer elemento que cumpla dicha condición en la colección

Update

db.<collection>.updateOne({conditions},{set:{changeValue:newValue}})

Actualiza el primer registro que cumpla con la condición

db.<collection>.updateMany({conditions},{set:{changeValue:newValue}})

Actualiza todos los registros que cumplan con una condición

Delete

db.inventory.deleteOne({Condition});

Elimina el primer registro que cumpla la condición

db.inventory.deleteMany({<Condition>});

Elimina todos los registros que cumplan con dicha condición

Al final de una función:

.count() Cuenta la cantidad de elementos retornados por un comando

.pretty()Muestra la infomación de manera más amigable

Queries de comparación

Ejemplo de query de comparación:

db.inventory.findOne({qty:{$lte:125}})

Si como yo, no pueden conectarse a MongoDB desde la terminal (a pesar de tener la IP incluida y todo en orden) usen la GUI de Mongo Compass, tiene un terminal incluida para ejecutar los comandos. Solamente asegúrense de estar en la base de datos correcta, con use paltzi-db.

.deleteOne()/Many()

.updateOne()/Many()

.findOne() - Orden Natural

.count()

.count()

.pretty()

.find()

.help()

.InsertOne()

En el minuto 3:27 falta una coma al final de soyId porque muestra error de sintaxis. Debe quedar así:

_id: "soyId", 

Si desean borrar una colección pueden usar el comando drop:
db.NOMBE_COLEC.drop()

hay que ser bastante cuidadoso con los cierres de llaves y demas

Mongo.exe
- Show dbs: Muestra las bases de datos
- Db usuarios: Entrar a la base de datos usuarios
- Db.usuarios.insertOne({…}): Insertar un elemento en formato json
- Show collections: Muestra una table
- Db.usuarios.findOne(): Muestra un indice de una tabla
- Db.inventory.insertMany()
- Db.inventory.find(filtro). pretty() / count()

Update
- db.inventory.updateOne({id}, {$set: {actualizacion} })
○ db.inventory.updateOne({_id: ObjectId(“60b105b1c9e7093189330fc1”)}, {$set: {qty: 30}})
- Update(…)

Delete
- Db.inventory. deleteOne / deleteMany
db.inventory.deleteOne( { status: “A” } )

Conectarse a MongoDB

mongo <URI Atlas>

Usar la base de datos creada de platzi

use platzi-db

El campo _id si no es agregado por nosotros de forma explícita, MongoDB lo agrega por nosotros como un ObjectId

el campo _id es obligatorio en todos los documentos

---------------------------------Create-----------------------------

db.inventory.insertOne(
{ item: “canvas”, qty: 100, tags: [“cotton”], size: { h: 28, w: 35.5, uom: “cm” } }
)

db.inventory.insertMany( [
{ item: “canvas”, qty: 100, size: { h: 28, w: 35.5, uom: “cm” }, status: “A” },
{ item: “journal”, qty: 25, size: { h: 14, w: 21, uom: “cm” }, status: “A” },
{ item: “mat”, qty: 85, size: { h: 27.9, w: 35.5, uom: “cm” }, status: “A” },
{ item: “mousepad”, qty: 25, size: { h: 19, w: 22.85, uom: “cm” }, status: “P” },
{ item: “notebook”, qty: 50, size: { h: 8.5, w: 11, uom: “in” }, status: “P” },
{ item: “paper”, qty: 100, size: { h: 8.5, w: 11, uom: “in” }, status: “D” },
{ item: “planner”, qty: 75, size: { h: 22.85, w: 30, uom: “cm” }, status: “D” },
{ item: “postcard”, qty: 45, size: { h: 10, w: 15.25, uom: “cm” }, status: “A” },
{ item: “sketchbook”, qty: 80, size: { h: 14, w: 21, uom: “cm” }, status: “A” },
{ item: “sketch pad”, qty: 95, size: { h: 22.85, w: 30.5, uom: “cm” }, status: “A” }
] )

db.inventory.find( { item: “canvas” } )

db.inventory.insertOne(
{ _id: “one”, item: “canvas”, qty: 100, tags: [“cotton”], size: { h: 28, w: 35.5, uom: “cm” } }
)

Atomicidad, todas las operaciones de escritura en MongoDB con atómicas a nivel de documentos

---------------------------------Read-------------------------------

db.inventory.find( {} )

Igualdad

db.inventory.find( { status: “D” } )

Operadores

db.inventory.find( { qty: { $gt: 30 } } )

Condición AND

db.inventory.find( { status: “A”, qty: { $lt: 30 } } )

Condición OR con operador

db.inventory.find( { $or: [ { status: “A” }, { qty: { $lt: 30 } } ] } )

Trae el primer documento que cumpla con el filtro de acuerdo al orden natural en que los documentos se encuentren guardados en disco

db.inventory.findOne( { status: “A”, qty: { $lt: 30 } } )

---------------------------------Update-----------------------------

Update One

db.inventory.updateOne(
{ item: “paper” },
{
$set: { “size.uom”: “cm”, status: “P” },
$currentDate: { lastModified: true }
})

Update Many

db.inventory.find({qty: {$lt: 50}})

db.inventory.updateMany(
{ “qty”: { $lt: 50 } },
{
$set: { “size.uom”: “in”, status: “P” },
$currentDate: { lastModified: true }
}
)

db.inventory.find({qty: {$lt: 50}})

Reemplazar un documento y conservar su _id

db.inventory.find({item: “paper”})

db.inventory.replaceOne(
{ item: “paper” },
{ item: “paper”, instock: [ { warehouse: “A”, qty: 60 }, { warehouse: “B”, qty: 40 } ] }
)

db.inventory.find({item: “paper”})

---------------------------------Delete-----------------------------

db.inventory.find({status: “A”})

Borrar muchos documentos de acuerdo a un filtro

db.inventory.deleteMany({ status : “A” })

db.inventory.find({status: “D”})

Borrar un documento

db.inventory.deleteOne( { status: “D” } )

Borrar todos los documentos de una base datos

db.inventory.deleteMany({})

¡Qué bien se siente hacer tu primer CRUD!

• 🎯⚛ Atomicity and Transactions in MongoDB

Aquí encontramos mas ejemplos

https://docs.mongodb.com/manual/tutorial/query-documents/

Excelente clase!!

Muy interesante, hay que tener mucho con el borrado o la actualziacion sin filtros.

¿Qué es más rápido? Un query de buscada mongodb o postgres/mysql/etc ?

Seria algo asi? Tuplas = Documentos, Colecciones = Tablas ?

Vamos bien!

Si Mongo utiliza atomicidad de documentos, cómo se manejaría la transaccionalidad de las inserciones?

Tengo un inconveniente con el driver para c#, tengo Visual Studio 2019
y la pagina me dice que la conecion se realiza asi
var mongoUrl = new MongoUrl(“mongodb+srv://User:<Password>@pruebachiAAA-verhd.mongodb.net”);
_client = new MongoClient(mongoUrl);
var db = _client.GetDatabase(“myfirstdb”);
var collection = db.GetCollection<Student>(“student”);
Student student = new Student(“Gino”, “Grimaldos”);
collection.InsertOne(student);

al ejecutarla tengo

MongoDB.Driver.MongoAuthenticationException: ‘Unable to authenticate using sasl protocol mechanism SCRAM-SHA-1.’

Como puedo arreglar ello y que la conexion se mantenga

De antemano gracias profe, me urge el tema.

Si Omito el ID, en un el comando updateOne, como se comporta MongoDB, Si encontrase 2 items iguales siguiendo el ejemplo visto en clases, modifica el primero que encuentra?, o modifica uno aleatoriamente?;

Estaría bueno compartir los json que estás usando para que facilites seguir los ejemplos. Más si se está usando la consola donde es poco amigable escribir json’s 😃

Increíble!!

Le entendí perfecto 😃

Una clase muy práctica! Son de las clases que más disfruto en los cursos de platzi!!

SELECT= db.{colección}.find / findOne( {condición} )
INSERT = db.{colección}.insertOne / insertMany( {JSON a insertar} )
UPDATE = db.{colección}.updateOne / updateMany( {condición}, {valor a actualizar} )
DELETE = db.{colección}.delteOne / deleteMany( {condición} )

Genial

Excelente

Muy interesante

Cómo sería en mongodb algo similar a los que en SQL seria?:

SELECT * FROM Table WHERE  field like "%query%"

Para pedir campos especificos en la consulta se agrega un el filtro + los campos que se quieran traer, ejemplo

db.collection.find({_id: "xxxx", qty: 2}, {_id: false, qty: true})

de esta forma la consulta solo traeria el documento que cumpla esa condicion y mostraria solo el field qty

El CRUD en mongo está muy padre, se siente mas intuitivo.

De donde saca la URL del clouster?

Estupenda clase instructor Albert, quedo clara la manera en que podemos aplicar las operaciones de CRUD por medio de la consola.

db.inventory.find({item: “canvas”}).pretty().count() formato bonito y cuenta los resultados
db.inventory.findOne({_id:ObjectId(“5f5aa1bf8206ae1148357b92”)})
db.inventory.findOne({_id:ObjectId(“5f5aa1bf8206ae1148357b92”), qty:{$lte:200}})
db.inventory.updateOne({_id:ObjectId(“5f5aa1bf8206ae1148357b92”)}, {$set:{qty:500}})
db.inventory.deleteOne({status: “A”}) Borra de uno en uno
db.inventory.deleteMany({status: “A”}) Borra todos los que encuentre

# Conectarse a MongoDB
mongo <URI Atlas>


# Usar la base de datos creada de platzi
use platzi-db


# El campo _id si no es agregado por nosotros de forma explícita, MongoDB lo agrega por nosotros como un ObjectId
# el campo _id es obligatorio en todos los documentos


# ---------------------------------Create-----------------------------
db.inventory.insertOne(
   { item: "canvas", qty: 100, tags: ["cotton"], size: { h: 28, w: 35.5, uom: "cm" } }
)


db.inventory.insertMany( [
   { item: "canvas", qty: 100, size: { h: 28, w: 35.5, uom: "cm" }, status: "A" },
   { item: "journal", qty: 25, size: { h: 14, w: 21, uom: "cm" }, status: "A" },
   { item: "mat", qty: 85, size: { h: 27.9, w: 35.5, uom: "cm" }, status: "A" },
   { item: "mousepad", qty: 25, size: { h: 19, w: 22.85, uom: "cm" }, status: "P" },
   { item: "notebook", qty: 50, size: { h: 8.5, w: 11, uom: "in" }, status: "P" },
   { item: "paper", qty: 100, size: { h: 8.5, w: 11, uom: "in" }, status: "D" },
   { item: "planner", qty: 75, size: { h: 22.85, w: 30, uom: "cm" }, status: "D" },
   { item: "postcard", qty: 45, size: { h: 10, w: 15.25, uom: "cm" }, status: "A" },
   { item: "sketchbook", qty: 80, size: { h: 14, w: 21, uom: "cm" }, status: "A" },
   { item: "sketch pad", qty: 95, size: { h: 22.85, w: 30.5, uom: "cm" }, status: "A" }
] )


db.inventory.find( { item: "canvas" } )


db.inventory.insertOne(
   { _id: "one", item: "canvas", qty: 100, tags: ["cotton"], size: { h: 28, w: 35.5, uom: "cm" } }
)
# Atomicidad, todas las operaciones de escritura en MongoDB con atómicas a nivel de documentos 


# ---------------------------------Read-------------------------------
db.inventory.find( {} )


# Igualdad 
db.inventory.find( { status: "D" } )


# Operadores
db.inventory.find( { qty: { $gt: 30 } } )


# Condición AND
db.inventory.find( { status: "A", qty: { $lt: 30 } } )


# Condición OR con operador
db.inventory.find( { $or: [ { status: "A" }, { qty: { $lt: 30 } } ] } )


# Trae el primer documento que cumpla con el filtro de acuerdo al orden natural en que los documentos se encuentren guardados en disco
db.inventory.findOne( { status: "A", qty: { $lt: 30 } } )


# ---------------------------------Update-----------------------------
# Update One
db.inventory.updateOne(
   { item: "paper" },
   {
     $set: { "size.uom": "cm", status: "P" },
     $currentDate: { lastModified: true }
   })
# Update Many
db.inventory.find({qty: {$lt: 50}})


db.inventory.updateMany(
   { "qty": { $lt: 50 } },
   {
     $set: { "size.uom": "in", status: "P" },
     $currentDate: { lastModified: true }
   }
)


db.inventory.find({qty: {$lt: 50}})


# Reemplazar un documento y conservar su _id
db.inventory.find({item: "paper"})


db.inventory.replaceOne(
   { item: "paper" },
   { item: "paper", instock: [ { warehouse: "A", qty: 60 }, { warehouse: "B", qty: 40 } ] }
)


db.inventory.find({item: "paper"})
# ---------------------------------Delete-----------------------------
db.inventory.find({status: "A"})
# Borrar muchos documentos de acuerdo a un filtro
db.inventory.deleteMany({ status : "A" })


db.inventory.find({status: "D"})
# Borrar un documento
db.inventory.deleteOne( { status: "D" } )


# Borrar todos los documentos de una base datos
db.inventory.deleteMany({})

Le falta como estructura aa este curso no me gusto mucho la verdad

Para usuarios MAC, el comando de limpiar la consola de Mongo es: CMD + K