Contar registros en MongoDB

  2. HowTo
  3. Procedimientos de MongoDB
  4. Contar registros en MongoDB
Tahseen Tauseef 12 octubre 2023
MongoDB MongoDB Record
  1. Operaciones en MongoDB
  2. Operación agregada en MongoDB
  3. $recuento en MongoDB
  4. db.colección.cuenta() en MongoDB
  5. Grupo MongoDB por conteo
  6. MongoDB Agrupar por conteo Ordenar
  7. Grupo MongoDB contando múltiples campos
  8. Agrupar MongoDB por fecha y recuento
  9. Método .toArray() en MongoDB
  10. .itcount() en MongoDB
Contar registros en MongoDB

Este artículo analiza los operadores en MongoDB, el operador agregado y los diferentes métodos para contar registros totales.

Operaciones en MongoDB

Las operaciones CRUD son los conceptos de una interfaz de usuario que permite a los usuarios navegar, buscar y cambiar objetos en una base de datos.

Los documentos de MongoDB se modifican conectándose a un servidor, consultando los documentos apropiados y luego transformándolos antes de enviar esos datos a la base de datos para su procesamiento. CRUD es un proceso basado en datos que utiliza verbos de acción HTTP para estandarizarlo.

  1. Crear: se utiliza para insertar nuevos documentos en la base de datos MongoDB.
  2. Leer: se utiliza para consultar un documento en la base de datos.
  3. Actualizar - se utiliza para modificar documentos existentes en la base de datos.
  4. Eliminar: elimina documentos de la base de datos.

Operación agregada en MongoDB

Es una operación de procesamiento de datos que consta de etapas que realizan muchas operaciones en datos agrupados para producir un solo resultado. Las siguientes son tres opciones para hacer la operación agregar.

  1. Pipeline para agregación: los documentos se suministran a través de un pipeline de múltiples etapas, integrándolos en una sola salida. El proceso agregado de MongoDB se divide en múltiples etapas.

    A continuación se muestra un ejemplo.

    db.collection_name.aggregate([

   //First stage
   { $match: { status: "" } },

   //Second stage
   { $group: { _id: "$cust_id", total: { $sum: "$amount" } } },

   //Third Stage
	{ $sort : {sort_field: -1 }}

])

  2. Métodos de agregación de propósito único: los métodos de agregación de propósito único son sencillos, pero carecen del poder de una canalización agregada.

  3. Map-Reduce: las operaciones Map-reduce han quedado obsoletas desde MongoDB 5.0. En su lugar, utilice una canalización agregada.

$recuento en MongoDB

Envía un documento al siguiente paso con un recuento del número de registros que ha recibido.

Comportamiento:

La siguiente secuencia $grupo + $proyecto es igual a la etapa $recuento.

db.collection.aggregate( [
   { $group: { _id: null, myCount: { $sum: 1 } } },
   { $project: { _id: 2 } }
] )

Donde indica myCount, el campo de salida contiene el recuento. Puede dar al campo de salida un nombre diferente.

Ejemplo:

Una colección llamada partituras tiene los documentos dados.

{ "_id" : 1, "subject" : "English", "score" : 88 }
{ "_id" : 2, "subject" : "English", "score" : 92 }
{ "_id" : 3, "subject" : "English", "score" : 97 }
{ "_id" : 4, "subject" : "English", "score" : 71 }
{ "_id" : 5, "subject" : "English", "score" : 79 }
{ "_id" : 6, "subject" : "English", "score" : 83 }

La siguiente operación de agregación tiene dos etapas.

  1. La etapa $match filtra los documentos que tienen un valor de score menor o igual a 80, permitiendo que los documentos con un score mayor a 80 pasen a la siguiente etapa.
  2. El paso $count calcula el número de documentos que quedan en la canalización agregada y almacena el resultado en una variable denominada passing_scores.
db.scores.aggregate(
  [
    {
      $match: {
        score: {
          $gt: 80
        }
      }
    },
    {
      $count: "passing_scores"
    }
  ]
)

La operación devuelve los siguientes resultados.

{ "passing_scores" : 4 }

Para obtener 1000 registros, se tarda en promedio 2 ms y es la forma más rápida.

db.colección.cuenta() en MongoDB

Devuelve el número de registros de la colección o vista que coincidirían con una consulta find(). La función db.collection.count() cuenta y proporciona el número de resultados que coinciden con una consulta en lugar del procedimiento find().

Comportamiento:

En las transacciones, no puede usar count o las herramientas de shell count() y db.collection.count().

Clústeres fragmentados

Si existen documentos huérfanos o hay una migración de fragmentos en proceso, el uso de db.collection.count() sin un predicado de consulta en un clúster fragmentado puede generar un recuento erróneo.

Utilice la función db.collection.aggregate() en un clúster fragmentado para evitar estas situaciones.

Para contar los documentos, utilice el paso $count. El siguiente procedimiento, por ejemplo, cuenta los documentos de una colección.

db.collection.aggregate( [
   { $count: "myCount" }
])

La etapa $count es igual a la siguiente secuencia $group + $project.

db.collection.aggregate( [
   { $group: { _id: null, count: { $sum: 1 } } }
   { $project: { _id: 0 } }
] )

Uso del índice

Considere una colección con el siguiente índice.

{ a: 1, b: 1 }

Al realizar un conteo, MongoDB solo puede usar el índice para devolver el conteo si la consulta:

  1. puede usar un índice,
  2. solo contiene condiciones sobre las claves del índice, y
  3. predica el acceso a un solo rango continuo de claves de índice

Por ejemplo, dado solo el índice, los siguientes procedimientos pueden devolver el recuento.

db.collection.find( { a: 5, b: 5 } ).count()
db.collection.find( { a: { $gt: 5 } } ).count()
db.collection.find( { a: 5, b: { $gt: 10 } } ).count()

Suponga que la consulta puede utilizar un índice, pero los predicados no alcanzan un único rango continuo de claves de índice. La consulta también tiene condiciones en campos fuera del índice.

En ese caso, MongoDB debe leer los documentos además de utilizar el índice para proporcionar el recuento.

db.collection.find( { a: 6, b: { $in: [ 1, 2, 3 ] } } ).count()
db.collection.find( { a: { $gt: 6 }, b: 5 } ).count()
db.collection.find( { a: 5, b: 5, c: 8 } ).count()

En tales circunstancias, MongoDB pagina los documentos en la memoria durante la lectura inicial, lo que mejora la velocidad de las llamadas posteriores a la misma operación de conteo.

Precisión en caso de un apagado inesperado

Las estadísticas de recuento proporcionadas por count() pueden ser erróneas después de un apagado incorrecto de un mongod que utiliza el motor de almacenamiento Wired Tiger.

Entre el último punto de control y el apagado incorrecto, la cantidad de operaciones de inserción, actualización o eliminación ejecutadas determina la cantidad de desviación.

Los puntos de control ocurren cada 60 segundos en promedio. Las instancias mongod con opciones -syncdelay no predeterminadas, por otro lado, pueden tener más o menos puntos de control.

Para restaurar las estadísticas después de un apagado incorrecto, ejecute validar en cada colección en el mongod.

Después de un apagado sucio:

  1. validar actualiza la estadística de conteo en la salida collStats con el valor más reciente.
  2. Otras estadísticas como el número de documentos insertados o eliminados en la salida collStats son estimaciones.

Desconexión del Cliente

A partir de MongoDB 4.2, si el cliente que emitió db.collection.count() se desconecta antes de que se complete la operación, MongoDB marca db.collection.count() para terminar usando killOp.

Contar todos los documentos en una colección

Para contar el número de todos los registros en la colección de pedidos, utilice la siguiente operación.

db.orders.count()

Esta operación es equivalente a la siguiente.

db.orders.find().count()

Cuente todos los documentos que coincidan con una consulta

Cuente cuántos documentos en la colección de pedidos tienen el campo ord_dt que es mayor que nueva Fecha ('01/01/2012').

db.orders.count( { ord_dt: { $gt: new Date('01/01/2012') } } )

La consulta es equivalente a la siguiente.

db.orders.find( { ord_dt: { $gt: new Date('01/01/2012') } } ).count()

Grupo MongoDB por conteo

A la columna _id de cada documento en MongoDB se le ha asignado un grupo único por valor. La técnica agregada luego procesa los datos, lo que produce resultados computados.

Lo siguiente es un ejemplo. La configuración de la base de datos se puede ver aquí.

Esta configuración se utilizará en todos los ejemplos de código presentados en este artículo.

db={
  "data": [
    {
      "_id": ObjectId("611a99100a3322fc1bd8c38b"),
      "fname": "Tom",
      "city": "United States of America",
      "courses": [
        "c#",
        "asp",
        "node"
      ]
    },
    {
      "_id": ObjectId("611a99340a3322fc1bd8c38c"),
      "fname": "Harry",
      "city": "Canada",
      "courses": [
        "python",
        "asp",
        "node"
      ]
    },
    {
      "_id": ObjectId("611a99510a3322fc1bd8c38d"),
      "fname": "Mikky",
      "city": "New Zealand",
      "courses": [
        "python",
        "asp",
        "c++"
      ]
    },
    {
      "_id": ObjectId("611b3e88a60b5002406571c3"),
      "fname": "Ron",
      "city": "United Kingdom",
      "courses": [
        "python",
        "django",
        "node"
      ]
    }
  ]
}

La consulta para la base de datos anterior utilizada es:

db.data.aggregate([
  {
    $group: {
      _id: "ObjectId",
      count: {
        $count: {}
      }
    }
  }
])

El enlace para la ejecución anterior se proporciona para ver el funcionamiento de este segmento de código.

agrupar por

MongoDB Agrupar por conteo Ordenar

En esta sección se utiliza $sortByCount, que es lo mismo que $group + $sort. Puede clasificar y contar un grupo de personas en orden ascendente y descendente.

A continuación se muestra una consulta de ejemplo. Se han agregado algunos documentos a la recopilación de datos en este ejemplo, y el método find() se usa para determinar cuántas entradas contiene.

La siguiente será la consulta de find().

db.data.find()

Puede acceder a la ejecución de esta consulta desde este enlace.

El siguiente paso es deshacer la matriz de cursos y usar la función $sortByCount para contar el número de registros agregados a cada curso.

db.data.aggregate([
  {
    $unwind: "$courses"
  },
  {
    $sortByCount: "$courses"
  }
])

El enlace se proporciona aquí para ver el funcionamiento de esta consulta con la configuración de la base de datos anterior. Este es el enfoque más sencillo para el grupo MongoDB contando la matriz y ordenándola.

agrupar por 2

Grupo MongoDB contando múltiples campos

La función agregar() de MongoDB puede contar varios campos. Como resultado, los campos se cuentan usando $count.

A continuación se muestra un ejemplo en el que se utiliza una marca de tiempo para una sola entrada. Algunos documentos se pueden guardar en la colección estudiante en este ejemplo, y puede usar el método buscar() para ver cuántos documentos tiene.

db.student.aggregate([ {$group: {_id: {name:"$name",
                                         timestamp:"$timestamp" }}},
                                        {$count:"timestamp"}
                      ])

La ejecución de esta consulta se puede acceder en este enlace.

Agrupar MongoDB por fecha y recuento

Cuando necesite contar un documento de fecha específico, puede utilizar la agregación de conteo y contar un documento de fecha específico.

Aquí hay una ilustración. En este ejemplo, aprenderá a calcular el monto de venta general y el recuento de ventas para cada día en 2021.

Puede incluir los campos id del producto, nombre del artículo, precio, cantidad y fecha en la colección ventas. Los documentos se pueden obtener mediante el método find().

db=
{
        "_id" : 1,
        "item" : "abc",
        "price" : NumberDecimal("10"),
        "quantity" : 2,
        "date" : ISODate("2021-03-01T08:00:00Z")
}
{
        "_id" : 2,
        "item" : "jkl",
        "price" : NumberDecimal("20"),
        "quantity" : 1,
        "date" : ISODate("2021-03-01T09:00:00Z")
}
{
        "_id" : 3,
        "item" : "xyz",
        "price" : NumberDecimal("5"),
        "quantity" : 10,
        "date" : ISODate("2021-03-15T09:00:00Z")
}
{
        "_id" : 4,
        "item" : "xyz",
        "price" : NumberDecimal("5"),
        "quantity" : 20,
        "date" : ISODate("2021-04-04T11:21:39.736Z")
}
{
        "_id" : 5,
        "item" : "abc",
        "price" : NumberDecimal("10"),
        "quantity" : 10,
        "date" : ISODate("2021-04-04T21:23:13.331Z")
}

La consulta para la configuración anterior será:

db.date.aggregate([
  {
    $match : { "date": { $gte: new ISODate("2021-01-01"), $lt: new ISODate("2015-01-01") } }
  },

  {
    $group : {
       _id : { $dateToString: { format: "%Y-%m-%d", date: "$date" } },
       totalSaleAmount: { $sum: { $multiply: [ "$price", "$quantity" ] } },

       count: { $sum: 1 }
    }
  },
  {
    $sort : { totalSaleAmount: -1 }
  }
 ])

Ahora, las consultas para un solo campo y varios grupos de campos se proporcionan a continuación utilizando los comandos recuento y campo.

  1. Agrupar un solo campo por y contar

    db.Request.aggregate([{'$group': {_id: '$source', count: {$sum: 1}}}])

  2. Múltiples campos agrupados y contados

    db.Request.aggregate([
  {'$group': {_id: {source: '$source', status: '$status'}, count: {$sum: 1}}}
])

  3. Múltiples campos agrupan por y cuentan con ordenar usando campo

    db.Request.aggregate([
  {'$group': {_id: {source: '$source', status: '$status'}, count: {$sum: 1}}},
  {$sort: {'_id.source': 1}}
])

  4. Múltiples campos agrupar por y contar con ordenar usando contar

    db.Request.aggregate([
  {'$group': {_id: {source: '$source', status: '$status'}, count: {$sum: 1}}},
  {$sort: {'count': -1}}
])

Método .toArray() en MongoDB

La función toArray() devuelve una matriz que contiene todos los documentos en un cursor. El procedimiento recorre el cursor muchas veces, cargando todos los documentos en la RAM y agotando el puntero.

Considere el siguiente ejemplo, que usa la función toArray() para transformar el cursor devuelto por el método find().

var allProductsArray = db.products.find().toArray();

if (allProductsArray.length > 0) {
  printjson(allProductsArray[0]);
}

La variable allProductsArray contiene la matriz de documentos devueltos por toArray(). Para obtener 1000 registros, esto toma, en promedio, 18 ms.

.itcount() en MongoDB

Cuenta cuántos documentos quedan en un cursor.

itcount() es similar a cursor.count(), pero en lugar de ejecutar la consulta en un nuevo iterador, la ejecuta en uno existente, agotando su contenido.

La forma prototipo del método itcount() es la siguiente.

db.collection.find(<query>).itcount()

Para obtener 1000 registros, esto toma, en promedio, 14 ms.

Este artículo discutió las operaciones en detalle, y también se discutió la operación agregada. Primero, se discutieron brevemente diferentes tipos de funciones agregadas con segmentos de código.

Luego se discutió el grupo por y el recuento, en el que se discutieron la clasificación, la búsqueda y los campos múltiples. Luego se discuten diferentes formas de contar los registros en MongoDB.

Artículo relacionado - MongoDB Record