Operadores para realizar queries y proyecciones

$eq     =
$gt      >
$gte   >=
$lt       <
$lte    <=
$ne    !=
$in     valores dentro de un rango
$nin    valores que no estan dentro de un rango
$and   Une queries con un AND logico
$not   Invierte el efecto de un query
$nor   Une queries con un NOR logico
$or      Une queries con un OR logico
$exist     Docuemntos que cuentan con un campo especifico
$type     Docuemntos que cuentan con un campo de un tipo especifico
$all          Arreglos que contengan todos los elementos del query
$elemMatch    Documentos que cumplen la condicion del $elemMatch en uno de sus elementos
$size    Documentos que contienen un campo tipo arreglo de un tamaño especifico.

Operadores para arreglo.
$all: Arreglos que contengan todos los elementos de la query.
$elementMatch: Documentos que cumplen la condición del $elementMatch en uno de sus elementos.
$size: Documentos que contienen un capo tipo arreglo de un tamaño específico.

Operadores de comparación en MongoDB.
$eq: Igual ‘=’.
$gt: Mayor ‘>’.
$gte: Mayor o igual ‘>=’.
$lt: Menor ‘<’.
$lte: Menor o igual ‘<=’.
$ne: Diferente ‘!=’.
$in: Valores dentro de un arreglo.
$nin: Valores que no están dentro de un arreglo.

Operadores lógicos.
$and: Une queries con un and lógico.
$not: Invierte el efecto de un query.
$nor: Une queries con un nor lógico.
$or: Une queries con un or lógico.

Operadores por elemento.
$exist: Documentos que cuentan con un campo específico.
$type: Documentos que cuentan con un campo de un tipo específico.

Las proyecciones me permiten indicarle a mongo cuales campos se necesitan que devuelva en la consulta, para esto se le indica con un 1 si se requiere que un campo se retorne y con 0 a los que se necesitan retornar.

...findOne( ... {item: 1, starus: 0} ...

Aquí en la documentación aparecen buenos ejemplos!
https://docs.mongodb.com/manual/tutorial/query-documents/

Operadores de comparación
$eq : Operador igual =.
$gt : Operador mayor que >.
$gte : Operador mayor o igual que >=.
$lt : Operador menor que >.
$lte : Operador manor o igual que >=.
$ne : Operador distinto de.
$in : Valores dentro de un arreglo.
$nin : Valores que no están dentro de un arreglo.
Operadores lógicos
$and : Une queries con un and lógico (similar al uso de una coma en un filtro).
$not : Invierte el efecto de una query.
$nor : Une queries con un nor lógico.
$or : Une queries con un or lógico (si una condición se cumple nos trae el documento) db.inventory.find( { $or: [ { status: “A” }, { qty: { $lt: 30 } } ] } ).
Operadores por elemento
$exist : Documentos que cuentan con un campo específico (Ejemplo: campo edad).
$type : Documentos que cuentan con un campo de un tipo específico (Ejemplo: tipo datetime).
Operadores para arreglos
$all : Arreglos que contengan todos los elementos de la query db.articles.find( { tags: { $all: [ [ “ssl”, “security” ] ] } } ).
$elemMatch : Documentos que cumplen la condición del $elemMatch en uno de sus documentos (condiciones dentro de subdocumentos) db.inventory.find( { “instock”: { $elemMatch: { qty: 5, warehouse: “A” } } } )
$size : Documentos que contienen un campo tipo arreglo de un tamaño específico.
https://docs.mongodb.com/manual/tutorial/query-documents/

No explico el operador nor, pillin

Profundización de queries dentro de MongoDB

Operadores para realizar queries y proyecciones

Filtros:

db.inventory.find({ status: { $in: [ "A", "D" ] } })

Proyecciones:

db.inventory.findOne({status: "A"})

{
  "_id": ObjectId("23d23d23fr23f23f"),
  "item": "journal",
  "status": "A",
  "size": {
    "h": 14,
    "w": 21,
    "uom": "cm"
  },
  "inStock": [
    {
      "warehouse": "A",
      "qty": 5
    }
  ]
}

Podemos ser más específicos:

db.inventory.findOne({status: "A"}, {item: 1, status: 1})

Ese 1 es valor booleano, así que le decimos que queremos solo los campos item y status.

{
  "_id": ObjectId("23d23d23fr23f23f"),
  "item": "journal",
  "status": "A"
}

Operadores de comparación:

Operadores lógicos:

Operadores por elemento:

Operadores para arreglos:

• Operadores de comparación en MongoDB.

$eq: Igual ‘=’.

$gt: Mayor ‘>’.

$gte: Mayor o igual ‘>=’.

$lt: Menor ‘<’.

$lte: Menor o igual ‘<=’.

$ne: Diferente ‘!=’.

$in: Valores dentro de un arreglo.

$nin: Valores que no están dentro de un arreglo.

• Operadores lógicos.

$and: Une queries con un and lógico.

$not: Invierte el efecto de un query.

$nor: Une queries con un nor lógico.

$or: Une queries con un or lógico.

• Operadores por elemento.

$exist: Documentos que cuentan con un campo específico.

$type: Documentos que cuentan con un campo de un tipo específico.

• Operadores para arreglo.

$all: Arreglos que contengan todos los elementos de la query.

$elementMatch: Documentos que cumplen la condición del $elementMatch en uno de sus elementos.

$size: Documentos que contienen un capo tipo arreglo de un tamaño específico.

Condición y atributos específicos

• Se pasa la condición de búsqueda ( en este ejemplo: {status: "A"} )
• Se establecen los atributos a mostrar (en este caso: {item: 1, status: 1}) → En SQL es el equivalente a especificar atributos en el SELECT

Super Clase !! Teoría que no se debe olvidar, tener muy en cuenta esta clase para cuando se realicen ejercicios prácticos

Pueden encontrar más información en este link:
Documentación

ndice de contenidos:

Tubería de agregación
Operadores de etapa
    $match, $project, $sort, $limit, $skip, $count, $group, $sample, $out, $addFields, y $sortByCount
Operadores de expresiones
    Operadores comparativos
        $eq, $ne, $gt, $gte, $lt, $lte y $cmp
    Operadores booleanos
        $and, $or y $not
    Operadores aritméticos
        $abs, $add, $multiply, $substract, $divide, $mod, $pow, $sqrt, $exp, $ln, $log, $ceil, $floor y $trunc
    Operadores sobre strings
        $concat, $split, $indexOfBytes, $strcasecmp, $toLower, $toUpper y $strLenCP
    Operadores de grupos (set):
        $setEquals, $setIntersection, $setUnion, $setDifference, $setInSubset, $anyElementTrue y $allElementsTrue
    Operadores sobre arregos (arrays)
        $arrayElementAt, $concatArrays, $filter, $in, $indexOfArray, $isArray,
        $map, $range, $reduce, $reverseArray, $size, $slice y $zip
    Operador de variable
        $let
    Operador literal
        $literal
    Operador de tipo de dato
        $type
    Operadores condicionales
        $cond, $ifNull y $switch
    Operadores sobre fechas
        $dayOfYear, $dayOfMonth, $dayOfWeek, $year, $month, $week, $hour, $minute, $second, $millisecond y $dateToString
    Acumuladores
        $sum, $avg, $max, $min, $first y $last

Query and Projection Operators

Así me lo aprendí yo (porque no se que significa cada cosa):

$eq: e = igual la q de equal, igual
$gt: Por Dragon Ball GT, que es la ultima de la saga sin contar super (el mayor) >
$gte: Dragon Ball GT + e (de igual) >=
$lt: Por lite, de pequeño, menor a <
$lte: Lite + e(de igual) <=
$ne: n = no, e = es No Es !=
$in = INside
$nin = Non INside

Sé que es una vil tonteria, pero yo asi aprendo las cosas, espero le sirva a alguien jajaja.

Yeeaa estaba esperando estos operadores

Comparation Operators

Alguien que ayude con la presentacion.

OPeradores de comparación en MongoDB

Operadores lògicos

OPeradores por elementos

Operadores para arreglos

ejemplo de los operadores para arreglos

ok,

Genial

$eq =
$gt >
$gte >=
$lt <
$lte <=
$ne !=
$in valores dentro de un rango
$nin valores que no estan dentro de un rango
$and Une queries con un AND logico
$not Invierte el efecto de un query
$nor Une queries con un NOR logico
$or Une queries con un OR logico
$exist Docuemntos que cuentan con un campo especifico
$type Docuemntos que cuentan con un campo de un tipo especifico
$all Arreglos que contengan todos los elementos del query
$elemMatch Documentos que cumplen la condicion del $elemMatch en uno de sus elementos
$size Documentos que contienen un campo tipo arreglo de un tamaño especifico.

Espero que ahora se entienda un poco mejor los operadores.

$eq: equal = igual
$gt:  greater > Mayor
$gte: greater equal >= Mayor igual
$lt: less that < Menor que
$lte: less equal <= Menor igual
$ne: not equal != no iguales

Query and Projection Operators

$exist