MongoDB comandos, definiciones y ejemplos

Acceder a un elemento de un arreglo por su número de posición (su index) en el arreglo

"<array>.<index>"

Acceder a un campo de un documento embebido dentro de un documento embebido

"<embedded document>.<embedded document>.<field>"

Acceder a un campo de un documento embebido

"<embedded document>.<field>"

db.collection.deleteOne()

Elimina un único documento de la colección basándose en el filtro.

db.collection.replaceOne()

Reemplaza un único documentos en la colección basándose en el filtro.

{$rename: {b: "c"}}

Renombra el campo b a c.

getIndexes()

Retorna los índices de cierta colección. db.<collectionName>.getIndexes() o también db.getCollection('<collectionName>').getIndexes()

Expresiones de aggregation

Se refiere al nombre del campo en los documentos introducidos. "$<fieldName>" Ejemplo ($age): { $group: { _id: "$age" } } Hay que colocar con comillas el campo en el aggregation framework para pasar como string. Si no se colocaran comillas en "$age" se interpretaría como una variable. En $group no se usa comillas dobles porque es un key, es el stage

db.collection.find()

Selecciona documentos en una colección basándose en el filtro y retorna un cursor a los elementos seleccionados.

Proyección en MongoDB

Significa seleccionar sólo los datos necesarios en vez de seleccionar todos los datos de un documento. Por ejemplo, si un documento tiene 5 campos y necesitas sólo 3 campos, seleccionas sólo esos 3 campos del documento.

Formato que típicamente tienen los comandos de MongoDB

db.<collection>.<method>( <filter>, <options>) db se refiere a la base de datos actual. <collection> es el nombre de la colección donde se hará la consulta. En <method>, sustituir el método de consulta deseado. Cada método tiene sus propias <options> para qué se hará con los documentos coincidentes.

¿Cómo crear un índice?

db.collection.createIndex( { <keyname>: [-1 | 1] }, <options> ) Ejemplos: db.persons.createIndex( { age: 1 } ) db.persons.createIndex( { name: 1 } )

Borrar index e indexes

db.collection.dropIndex({<fieldName>:1}) db.collection.dropIndexes() dropIndexes() no necesita argumentos Ejemplos: db.persons.dropIndex({age:1}) db.persons.dropIndexes()

Combinación de $match stage y $group stage

db.persons.aggregate( [ { $match: {favoriteFruit: "banana" } }, { $group: { _id: {age: "$age", eyeColor: "$eyeColor"} } } ] ) En este ejemplo primero en el match stage se filtrarán los documentos para obtener solo aquellos que tengan banana como favoriteFruit, y luego en el group stage se agruparán esos documentos obtenidos para obtener documentos con _id con valor igual a un documento embebido con campos age y eyeColor, un documento para cada combinación posible.

Usuario que realizó más tweets (Pasos: 1. Agrupar tweets por usuario 2. Contar cantidad de tweets de cada usuario 3. Ordenar en orden descendiente 4. Seleccionar el primer usuario en esa lista

db.tweets.aggregate( [ { "$group" : { "_id" : "$user.screen_name", "count" : { "$sum" : 1 } } }, { "$sort" : { "count" : -1 } } ] ) En el primer stage se agrupa todos los usuarios que tengan el mismo valor de user.screen_name y usa el acumulador count con operador de acumulador $sum, por cada documento que tenga el mismo valor de user.screen_name, incrementar en count el valor 1. Luego ordena en orden descendiente según el valor de count de los documentos que ingresan a ese stage. Al final obtenemos un conjunto de documentos con campo _id que tiene valor del count de tweets por usuario.

Dados los siguientes elementos en la colección scores: { _id: 1, results: [ 82, 85, 88 ] } { _id: 2, results: [ 75, 88, 89 ] } La siguiente consulta retorna solamente los documentos donde el arreglo results contiene al menos un elemento que sea mayor o igual a 80 y sea menor a 85 (que cumpla ambas cosas): db.scores.find( { results: { $elemMatch: { $gte: 80, $lt: 85 } } }) ¿Cuál elemento retornará la consulta?

{ "_id" : 1, "results" : [ 82, 85, 88 ] }

{a: {$not: {$type: 2}}}

Documentos donde a no es un string. $not niega cualquiera de los otros operadores de consulta.

{a: {$elemMatch: {b: 1, c:2}}}

Documentos donde el campo a es un arreglo que contiene un elemento donde b es igual a 1 y c es igual a 2 (documentos que contengan un arreglo que contenga al menos un elemento que cumpla todas las condiciones).

{"a.b": 10}

Documentos donde el campo a es un documento embebido con b igual a 10.

{ a: { $nin: [ 10, "hello" ] } }

Documentos donde tags no es igual a 10 ni "hello" o donde es un arreglo que no contiene 10 ni "hello" (donde no sea igual a ningún elemento del arreglo, o si el valor también es un arreglo que no contenga ninguno de los elementos del arreglo del parámetro) o donde no exista ese arreglo.

{$text: {$search: "hello"}}

Documentos que contienen "hello" en una búsqueda completa de texto o full-text-search.

{a: {$exists: true}}

Documentos que contienen un campo llamado a.

Ejemplo de uso de index

Ejemplo usando el index age: db.getCollection('persons').find({age: {$gt:27}})

{$unset: {a: 1}}

Elimina el key a.

{$pop: {b: -1}}

Elimina el primer elemento del arreglo b.

{$pop: {b: 1}}

Elimina el último elemento del arreglo b.

{$pullAll: {b: [5, 6]}}

Elimina múltiples ocurrencias de 5 o 6 en el arreglo b.

db.collection.deleteMany()

Elimina todos los documentos de la colección que coincidan con el filtro.

{$pull: {b: ($gt: 5}}}

Elimina todos los valores mayores que 5 del arreglo b.

Operadores o stages de pipeline

- $match: Filtra documentos según un parámetro. (n:1) - $group: Realiza la agregación (n:1) Agrupa documentos según algún criterio creando nuevos documentos para cada grupo. - $project: Filtra campos en el documento. Su función es "recolocar" el documento. Selecciona las claves que se usarán, y puede "elevar" claves que están en subdocumentos al nivel superior. Tras un paso $project habrá tantos documentos como inicialmente; pero con un formato que puede haber variado. (1:1) - $sort: Ordena. (1:1) - $count: Retorna un conteo del número de documentos en el stage en el que se encuentre el aggregation pipeline en ese momento. - $limit: Limita el número de documentos. Número de elementos máximo. n:1 - $skip: Salta una cierta cantidad de documentos. n:1 - $out: crea una colección nueva a partir del resultado de la agregación. 1:1 - $unwind: "aplana" datos de arrays, produciendo tantos elementos como elementos tenga el array. 1:n - $redact: Seguridad. Impide que algunos usuarios vean algunos documentos. n:1 - $geonear: Se utiliza para búsquedas por posición (ver índices geoespaciales). n:1 - $sample: permite elegir al azar unos cuantos documentos a modo de muestra. n:1 - $lookup: join the varias colecciones

Opciones para creación de índice

- Crear índice en background. Otras operaciones de la colección no serán bloqueadas o interrumpidas: { background: true } - Crear índice único (valores de ese campo deben ser únicos en la colección): { unique: true } - Especificar nombre para el index: { name: "<indexName>" } Ejemplos: db.persons.createIndex( { lastname:1 }, {unique:true} ) db.persons.createIndex( { age:1 }, {background:true} )

db.collection.updateMany()

Actualiza todos los documentos en una colección que coincidan con el filtro.

db.collection.updateOne()

Actualiza un único documento en la colección básandose en el filtro.

{$push: {b: {$each: [1, 2]}}}

Anexa 1 y 2 al arreglo b (anexa cada elemento especificado).

{$addToSet: {b: {$each: [1,2]}}}

Anexa 1 y 2 al arreglo b solo si aun no existen.

{$push: {b: {$each: [10, 20,30], $slice: -5}}}

Anexa 10, 20 y 30 al arreglo b, luego recorta el arreglo resultante para que solo contenga los últimos 5 elementos. (en $slice se coloca valor positivo si queremos los primeros elementos y valor negativo si queremos los últimos elementos, $slice solo se puede usar con $each).

{$addToSet: {b: 1}}

Anexa el valor 1 al arreglo b solo si el valor aún no existe.

{$push: {b: 1}}

Anexa el valor 1 al arreglo b.

Pasos para hacer un ejemplo de Aggregation requests***

Antes que todo, necesitamos tener una colección sample, por ejemplo insertar en una colección persons con el método db.persons.insertMany() y colocar los documentos dentro del paréntesis, o importar persons.json a la colección. 1. ***

Indexes (Índices)

Cada index se crea con un key que contiene un par key-value, donde key es el nombre del campo y el valor es 1 o -1. 1 significa que se ordenará de forma ascendente y -1 significa que se ordenará de forma descendente. Mongodb tomará los valores de cierto campo de varios documentos y los ordenará, y cada valor apuntará a cierto documento. Cuando un índice es creado, éste es guardado junto a los datos de la colección.

use <db>

Cambia la base de datos actual a <db>. La variable db del shell de mongo es igual a la base de datos actual.

Consultas no indexables

Consultas que no pueden usar indexes serán ejecutadas como escaneos de colecciones, escaneando todos los documentos en la colección, lo que tendrá un performance pobre en escala. Para evitar escaneos de colecciones, estas formas de consultas normalmente deberían estar acompañadas de al menos un otro término de consulta que sí utilice un index.

Data Aggregation

Data Aggregation es cualquier proceso en el que la información se recopila y se expresa en forma de resumen para fines tales como el análisis estadístico.

{a: /foo.*bar/}

Documentos donde a coincide con la expresión regular foo.*bar

{a: /^m/} o también {a: {$regex:"^m"}}

Documentos donde a empieza con la letra m.

{$or: [{a: 1}, {b: 2}]}

Documentos donde a es 1 o b es 2.

{a: 10} o la siguiente forma: {a: {$eq: 10}}

Documentos donde a es 10 o un arreglo que contiene el valor 10. Se pueden usar ambas formas excepto en casos donde el parámetro no se puede expresar con sintaxis de asignación (por ejemplo en aggregation) y se debe expresar con operadores.

{a: 10, b: "hello"}

Documentos donde a es 10 y b es "hello"

{a: {$nin: [10, "hello"]}}

Documentos donde a es cualquier cosa menos 10 o "hello".

{ a: { $in: [ 10, "hello" ] } }

Documentos donde a es igual a 10 o "hello", o donde es un arreglo que contiene 10 o "hello" (donde es igual a cualquiera de los elementos del arreglo, o si el valor también es un arreglo que contenga al menos uno de los elementos del arreglo del parámetro).

{a: {$gte: 10}}

Documentos donde a es mayor o igual que 10.

{a: {$gt: 10}}

Documentos donde a es mayor que 10.

{a: {$lte: 10}}

Documentos donde a es menor o igual que 10.

{a: {$lt: 10}}

Documentos donde a es menor que 10.

{a: {$size: 3}}

Documentos donde a es un arreglo con exactamente 3 elementos.

{a: {$all: [10, "hello"]}}

Documentos donde a es un arreglo que contiene 10 y "hello" (contiene todos los elementos del arreglo del parámetro).

{a: {$type: "string"}}

Documentos donde a es un string.

{a: {$mod: [10, 1]}}

Documentos donde a mod 10 es 1. Mod es el resto de una división.

{a: {$ne: 10}}

Documentos donde a no es igual a 10.

Aggregation Pipeline

Es un framework para Data Aggregation modelado en el concepto de pipelines o tuberías de procesamiento de datos. Permite agrupar documentos en las colecciones según condiciones específicas. Estructura tipo "pipeline": diferentes etapas, donde cada una toma la salida de la anterior. El MongoDB aggregation pipeline consiste de stages. Los documentos entran y se procesan en un pipeline o tubería de múltiples stages o etapas que transforman los documentos en resultados que están aggregated. MongoDB provee el método db.collection.aggregate() en el shell de mongo y el comando aggregate para ejecutar el aggregation pipeline. db.<collection>.aggregate( [ { <stage1> }, { <stage2> }, ... { <stageN> }]) Los elementos de la "tubería" (pipeline) se incluyen en un arreglo y se ejecutarán por orden. Cada elemento puede repetirse y el orden puede variar. Por ejemplo: db.orders.aggregate([ { $match: { status: "A" } }, { $group: { _id: "$cust_id", total: { $sum: "$amount" } } } ]) - Primer stage del ejemplo: El stage $match filtra los documentos según el campo de status y pasa al siguiente stage los documentos que tengan status igual a "A". - Segundo stage del ejemplo: El stage $group agrupa los documentos según el campo de cust_id para calcular la suma de la cantidad para cada cust_id único.

{$max: {a: 10}}

Establece a al que sea el mayor valor, su valor actual o 10. Si a no existe, establece a con valor 10.

{$min: {a: -10}}

Establece a al que sea el menor valor, su valor actual o -10. Si a no existe, establece a con valor -10.

{$mul: {b: 2}}

Establece b al producto del valor actual de b y 2. Si b no existe establece b con valor 0.

{$setOnInsert: {b: 1}},{upsert: true}

Establece el campo b a 1 en caso de una operación upsert.

{$currentDate: {b: {$type:"date"}}}

Establece el campo b a la fecha actual. $currentDate puede ser especificado como date o timestamp.

{$set: {a: 5}}

Establece que el valor de a es 5.

$match stage

Filtra documentos según query. { $match: { <query> } } Si solo se usa el match stage sin otros stages es como un find. Match usa consultas estándar de MongoDB y soporta todas los operadores de consultas. Ejemplos: { $match: { city: "New York" } } { $match: { age: {$gt: 25} } } { $match: {$and: [ {gender:female}, {age: {$gt:25} } ] } } Ejemplos completos: db.persons.aggregate( [ { $match: { age: {$gt: 25} } } ] } db.persons.aggregate( [ { $match: { tags: { $size: 3 } } } ] } El anterior devuelve donde el array tags tiene 3 elementos.

{$inc: {a: 2}}

Incrementa a en 2 números (suma 2 al valor de a)

{$push: {b: {$each: [50, 60,70], $position: 0}}}

Inserta 50, 60 y 70 empezando desde la posición 0 del arreglo b. ($position solo se puede usar con el modificador $each)

db.collection.insertMany()

Inserta mútiples documentos en una colección.

db.collection.insertOne()

Inserta un documento en una colección.

Parámetros de filtro de consultas

MongoDB utiliza una estructura de clave-valor para crear parámetros de filtro de consultas. Por ejemplo, la siguiente consulta encuentra todos los documentos en la colección llamada inventory en donde el campo qty contiene un valor mayor a 10: db.inventory.find({ "qty" : { $gt: 10 }}) Formato de parámetro: { <field1>: { <operator1>: <value1> }, ... } Las consultas toman a documentos como parámetros de filtro de consultas. Se pueden incluir múltiples parámetros de filtro en un documentos, separados por comas.

help

Muestra ayuda

db.<collection>.help()

Muestra ayuda sobre métodos de colecciones. <collection> puede ser el nombre de una colección existente o no existente.

show profile

Muestra una lista con las 5 operaciones más recientes que tomaron 1 milisegundo o más.

show databases

Muestra una lista con todas las bases de datos disponibles.

show dbs

Muestra una lista con todas las bases de datos en el servidor.

show collections

Muestra una lista de todas las colecciones de la base de datos actual.

show roles

Muestra una lista de todos los roles (los creados por usuarios y los que vienen predeterminados) de la base de datos actual.

show users

Muestra una lista de usuarios de la base de datos actual.

$group stage

Para agrupar documentos según el nombre del campo. { $group: { _id: <expression>, <field1>: { <accumulator1> : <expression1> }, ... } } Donde los key son campos y los valores son expresiones. El campo _id es obligatorio. Se obtendrán como resultado documentos con un campo que es _id, y los valores dependerán de los valores del campo input que se usó en expresión. Los valores que se obtienen son todos los distintos valores que hay del campo especificado o todas las combinaciones distintas que hay de más campos (un documento para cada valor que tendrá _id). Ejemplos: db.persons.aggregate( [ { $group: { _id: "$age" } } ] ) En este ejemplo se agrupa según el campo age de los documentos, luego se encuentran todos los valores distintos del campo age, y luego se produce un nuevo conjunto de documentos. Cada uno de esos documentos tendrán un solo campo que será _id y los valores serán distintos valores del campo age de los documentos que se introdujeron al stage al inicio. db.persons.aggregate( [ { $group: { _id: { age: "$age", gender: "$gender"} } } ] ) En este ejemplo en un lugar de una sola expresión le pasamos un objeto con 2 pares clave-valor. Se agrupará por pares, age y gender. Se encontrarán todos los pares únicos en todos los documentos a agrupar y esto se retornará en documentos separados y cada documento retornado tendrá solo el campo _id cuyo valor será un documento embebido que contendrá dos campos, age y gender. db.persons.aggregate( [ { $group: { _id: "$company.location.country" ]) En este ejemplo el resultado será un conjunto de documentos donde cada documento tendrá _id según cada país distinto que hay entre todos los documentos que fueron input. El group stage puede tener más campos además de _id y esos nuevos campos pueden ser calculados dinámicamente utilizando acumuladores.

{$bit: {b: {and: 7}}}

Realiza la operación bitwise and en el campo b: 1000 0100 ------- 110 Soporta operaciones bitwise and/xor/or.