show collections

////////////////////////////////////////////////////////////////
// Operaciones básicas de Create/Read/Update/Delete (CRUD): ////
////////////////////////////////////////////////////////////////

/////////////// Insertar (Create) /////////////////////////

// Insertar un empleado en la base de datos
// Cada inserción devuelve reconocido verdadero o falso
// Cada documento tiene un valor _id único asignado automáticamente
db.engineers.insertOne({ name: "Jane Doe", age: 21, gender: 'Female' })

// Insertar una lista de empleados en la colección `engineers`
// Puede insertarse como una matriz de objetos
db.engineers.insert([
  { name: "Foo Bar", age: 25, gender: 'Male' },
  { name: "Baz Qux", age: 27, gender: 'Other' },
])

// MongoDB no impone un esquema o estructura para objetos
// Inserta un objeto vacío en la colección `engineers`
db.engineers.insertOne({})

// Los campos son opcionales y no tienen que coincidir con el resto de los documentos
db.engineers.insertOne({ name: "Your Name", gender: "Male" })

// Los tipos pueden variar y se conservan en la inserción
// Esto puede requerir una validación adicional en algunos idiomas para evitar problemas
db.engineers.insert({ name: ['Foo', 'Bar'], age: 3.14, gender: true })

// Los objetos o matrices se pueden anidar dentro de un documento
db.engineers.insertOne({
  name: "Your Name",
  gender: "Female",
  skilledIn: [
    "MongoDB",
    "NoSQL",
  ],
  "date-of-birth": {
    "date": "1993-07-20T09:44:18.674Z",
    "age": 26
  },
})

// Podemos anular el campo _id
// Funciona biendb.engineers.insertOne({
  _id: 1,
  name: "An Engineer",
  age: 25,
  gender: "Female",
})

// Tenga cuidado, ya que _id SIEMPRE debe ser único para la colección, de lo contrario
// la inserción fallará
// Falla con un WriteError que indica que _id es un valor duplicado
db.engineers.insertOne({
  _id: 1,
  name: "Another Engineer",
  age: 25,
  gender: "Male",
})

// Funciona bien ya que esta es una colección diferente
db.doctors.insertOne({
  _id: 1,
  name: "Some Doctor",
  age: 26,
  gender: "Other",
})

/////////////////// Buscar (Read) ////////////////////////
// Las consultas tienen la forma de db.collectionName.find(<filter>)
// Donde <filtro> es un objeto

// Mostrar todo en nuestra base de datos hasta el momento, limitado a un
// máximo de 20 documentos a la vez
// Presione i para iterar este cursor a los siguientes 20 documentos
db.engineers.find({})

// Podemos imprimir bastante el resultado de cualquier consulta find()
db.engineers.find({}).pretty()

// Las consultas de MongoDB toman un objeto JS y buscan documentos que coincidan
// pares clave-valor
// Devuelve la consulta de coincidencia del primer documento
// NOTA: El orden de inserción no se conserva en la base de datos, la salida puede variar
db.engineers.findOne({ name: 'Foo Bar' })

// Devuelve todos los documentos con las propiedades clave-valor coincidentes como un cursor
// (que se puede convertir en una matriz)
db.engineers.find({ age: 25 })

// El tipo importa cuando se trata de consultas
// No devuelve nada ya que todas las edades anteriores son de tipo entero
db.engineers.find({ age: '25' })

// find() admite matrices y objetos anidados al igual que create()
db.engineers.find({
  name: "Your Name",
  gender: "Female",
  skilledIn: [
    "MongoDB",
    "NoSQL",
  ],
  "date-of-birth": {
    "date": 1993-07-20T09:44:18.674Z,
    "age": 26
  },
})

///////////////////////// Actualizar ////////////////////////
// Las consultas tienen la forma de db.collectionName.update(<filtro>, <actualización>)
// NOTA: <update> siempre usará el operador $set.
// Varios operadores se tratan más adelante en el tutorial.

// Podemos actualizar un solo objeto
db.engineers.updateOne({ name: 'Foo Bar' }, { $set: { name: 'John Doe', age: 100 }})

// O actualizar muchos objetos al mismo tiempo
db.engineers.update({ age: 25 }, { $set: { age: 26 }})

// Podemos usar { upsert: true } si queremos que se inserte si el documento aún no existe,
// o para actualizar si lo hace
// Devuelve el conteo coincidente, alterado y modificado
db.engineers.update({ name: 'Foo Baz' },
  { $set:
    {
      age: 26,
      gender: 'Other'
    }
  },
  { upsert: true }
)

/////////////////////// Borrar /////////////////////////
// Las consultas tienen la forma de db.collectionName.find(<filter>)

// Eliminar la consulta de coincidencia del primer documento, siempre devuelve deleteCount
db.engineers.deleteOne({ name: 'Foo Baz' })

// Eliminar muchos documentos a la vez
db.engineers.deleteMany({ gender: 'Male' })

// NOTA: Hay dos métodos db.collection.removeOne(<filtro>) y
// db.collection.removeMany(<filtro>) que también eliminan objetos pero tienen un
// valor de retorno ligeramente diferente.
// No se incluyen aquí porque han quedado obsoletos en el controlador NodeJS.

/////////////////////////////////////////////////// ///////
//////////////////// Operadores ///////////////////////////
/////////////////////////////////////////////////// ///////

// Los operadores en MongoDB tienen un prefijo $. Para este tutorial, solo buscamos
// en comparación y operadores lógicos, pero hay muchos otros tipos de
// operadores

//////////////// Operadores de comparación ///////////////////

// Encuentra todo mayor que o mayor que igual a alguna condición
db.engineers.find({ $gt: { age: 25 }})
db.engineers.find({ $gte: { age: 25 }})

// Encuentra todo menor que o menor que igual a alguna condición
db.engineers.find({ $lt: { age: 25 }})
db.engineers.find({ $lte: { age: 25 }})

// Encuentra todos iguales o no iguales a
// Nota: el operador $eq se agrega implícitamente en la mayoría de las consultas
db.engineers.find({ $eq: { age: 25 }})
db.engineers.find({ $ne: { age: 25 }})

// Encuentra todo lo que coincida con cualquier elemento en la matriz
db.engineers.find({ age: ${ in: [ 20, 23, 24, 25 ]}})

//////////////// Operadores logicos ///////////////////

// Une dos cláusulas de consulta
// NOTA: MongoDB hace esto implícitamente para la mayoría de las consultas
db.engineers.find({ $and: [
  gender: 'Female',
  age: {
    $gte: 18
  }
]})

// Coincide con cualquiera de las condiciones de la consulta
db.engineers.find({ $or: [
  gender: 'Female',
  age: {
    $gte: 18
  }
]})

// Niega la consulta
db.engineers.find({ $not: {
  gender: 'Female'
}})

// No debe coincidir con ninguna de las condiciones de consulta
db.engineers.find({ $nor [
  gender: 'Female',
  age: {
    $gte: 18
  }
]})

///////////////////////////////////////////////////////////
//////////////// Operaciones de base de datos: ////////////
///////////////////////////////////////////////////////////

// Eliminar (soltar) la base de datos de empleados
// ¡ESTO BORRARÁ TODOS LOS DOCUMENTOS EN LA BASE DE DATOS!
db.dropDatabase()

// Crea una nueva base de datos con algunos datos
use example
db.test.insertOne({ name: "Testing data, please ignore!", type: "Test" })