MongoDB for Dummies (like me)
Tags: mongodb, spanish, beginners, tutorial
Published: 2022-05-29 16:34:11

## Ejecutables
- https://www.mongodb.com/docs/manual/installation/
- https://www.mongodb.com/try/download/shell

## Comandos básicos

- Conecta a tu instancia local de MongoDB
```
mongosh
```
- Muestra todas las bases de datos
- Muestra todas las colecciones de la actual base de datos
```
show dbs
show collections
```
- Cambia a la base de datos ingresada
```
use <nombre_bd>
```
- Muestra tu actual BD 
```
db
```
- Elimina tu actual BD
```
db.dropDatabase()
```
- Crear colección
```
db.createCollection(<Name>, Options)

db.createCollection(<Name>, {
   capped : true,
   size : sizeLimit,
   max : documentLimit,
   validator: { $and:
      [   { phone: { $type: "string" } },
          { email: { $regex: /@flares\.com$/ } },
          { status: { $in: [ "Registered", "Unknown" ] } }
       ]
    }
})

db.createCollection( 'login', {
    validator: { $jsonSchema: {
        bsonType: "object",
        "additionalProperties": false,
       required: [ "email" ],
       properties: {
          email: {
             bsonType : "string",
             pattern : "@flares\.com$",
             description: "string meets the given expression"
          },
          status: {
             enum: [ "registered", "Invalid" ],
             description: "status must be within enum values"
          }
       }
    } },
} )
```
- Cambiar nombre de colección
```
db.<db_name>.renameCollection(<new_name_collection>)
db.login.renameCollection(<newCollectionName>)
```

----------------------------------------------

## Create
db.\<collectionName\>.\<command\>
- insertOne *collectionName.insertOne({document})*
- insertMany *collectionName.insertMany([{document1},{document2},{ document3}….{ documentn}])*

Crea uno o varios documentos dentro de una colección
```
db.users.insert({
   name: 'Fernando',
   age: 35,
   interesting: ['tecnology, 'music', 'movies'],
   address: {
      city: 'Santiago',
      street: 'Columbus av.'
   }.
   birdDate: Date()
})
db.users.insertOne({ name: "Fernando"})
db.users.insertMany({ name: "Fernando"}, {name: "Elias"})
```

----------------------------------------------

## Read
db.\<collectionName\>.\<command\>

- find()
- find(\<filterObject\>)
- find(\<filterObject\>, \<selectObject\>)
```
db.users.find().pretty()
db.users.find({ name: "Fernando"})
db.users.find({ email: "fernando@mail.com"}, {name: 1})
db.users.find({}, {email: 0})
```
El primer comando muestra todos los documentos de la colección.
El segundo muestra todos los documentos cuyo `name` sea `Fernando`.
El tercero muestra unicamente el `name` de los documentos cuyo `email` sea `fernando@mail.com`
El cuarto muestra todos los documentos excepto el campo `email`

- findOne(\<filterObject\>)
```
db.users.findOne({ name: "Fernando"})
```
Muestra sólo el primer documento que cumple el filtro

- countDocuments(\<filterObject\>)
```
db.users.countDocuments({ name: "Fernando"})
```
Regresa el número de documentos que cumple el filtro

----------------------------------------------

## Update
db.\<collectionName\>.\<command\>


- updateOne
- updateMany
```
db.users.updateOne({ age: 20 }, { $set: { age: 21 } })
db.users.updateMany({ age: 12 }, { $set: { age: 15 } })
```
El primero actualiza la edad del primer documento que encuentra, en cambio el segundo actualiza todos los documentos que cumplan el filtro.

- replaceOne
```
db.users.replaceOne({ age: 12 }, { name:"mi nombre", age: 13 })
```
Reemplaza el primer objeto completo que cumpla el filtro

----------------------------------------------

## Delete
db.\<collectionName\>.\<command\>

- deleteOne
- deleteMany
```
db.users.deleteOne({age: 10})
db.users.deleteMany({age: 10})
```
El primer comando elimina el primer documento que cumpla el filtro y el segundo borra todos los documentos que cumplan el filtro

----------------------------------------------

## Filters

- $eq (equal)
- $ne (not equal)
```
db.users.find({ name: { $eq: "Fernando" } })
db.users.find({ name: { $ne: "Fernando" } })
```
El primero muestra todos los documentos cuyo `name` sea igual a `Fernando` y el segundo todos los que sean diferentes.

- $gt (greater than)
- $gte (greater than or equal)
- $lt (low than)
- $lte (low than or equal)
```
b.users.find({ age: { $gt: 12 } })
db.users.find({ age: { $gte: 15 } })

b.users.find({ age: { $lt: 12 } })
db.users.find({ age: { $lte: 15 } })
```
El primer comando muestra los documentos con un `age` mayor a 12, sin incluirlo.
El segundo muestra los documentos con un `àge` mayor a 15 incluyendo los que tengan 15.
Los dos siguientes de igual forma incluyendo o excluyéndolos del filtro.

- $in (include)
- $nin (non include)
```
db.users.find({ name: { $in: ["Fernando", "Jose"] } })
db.users.find({ name: { $nin: ["Fernando", "Jose"] } })
```
El primer comando muestra los documentos cuyo `name` se encuentra en el arreglo y el segundo todos los que no se encuentren

- $and
- $or
- $not
```
db.users.find({ $and: [{ age: 12 }, { name: "Fernando" }] })
db.users.find({ $or: [{ age: 12 }, { name: "Fernando" }] })
db.users.find({ name: { $not: { $eq: "Fernando" } } })
```
El primer comando muestra los documentos que cumplen ambos filtros, el segundo sólo necesita cumplir uno de los filtros, el tercero invierte la selección dentro del filtro.

- $exist
```
db.users.find({ name: { $exists: true } })
```
Muestra los documentos que poseen un campo llamado `name`

- $expr
```
db.users.find({ $expr: { $gt: ["$nota1", "$nota2"] } })

```
Realiza la comparación entre diferentes campos, en el ejemplo se muestran los documentos cuya `nota1` es mayor a su `nota2`

----------------------------------------------

## Read Modifiers
Formatear salida
- pretty()
```
db.users.find({ age: 10}).pretty();
```
Obtener registros únicos
- distinct() *collectionName.distinct(field,query)*
```
db.users.distinct("name")
```

Se pueden agregar al final de diferentes operaciones

- sort
- limit
- skip
```
db.users.find().sort({ name: 1 })
db.users.find().limit(2)
db.users.find().skip(4)
```
El primer comando ordena de forma alfabéticamente los documentos según el nombre.
El segundo sólo muestra los 2 primeros documentos.
El tercero omite los 4 primeros resultados

----------------------------------------------

## Complex Update Object

- $set
- $inc
- $rename
- $unset
```
b.users.updateOne({ age: 12 }, { $set: { name: "jose" } })
b.users.updateOne({ age: 12 }, { $inc: { age: 2 } })
b.users.updateMany({}, { $rename: { age: "years" } })
db.users.updateOne({ age: 12 }, { $unset: { age: "" } })
```
El primer comando actualiza el `name` del primer documento que posea un `age` de 12
El segundo incrementa en 2 el `age` del primer documento que posea un `age` de 12
El tercero cambia el nombre del campo `age` a `years` de todos los documentos
El cuarto elimina el campo `age` del primer documentos con un `age` de 12


- $push
- $pull
```
b.users.updateMany({}, { $push: { friends: "John" } })
b.users.updateMany({}, { $pull: { friends: "Miguel" } })
```
El primero agrega un valor a al arreglo `friends`, el segundo elimina el valor , ambos de todos los documentos.