Datensätze in MongoDB zählen

  2. How-To's
  3. MongoDB-Howtos
  4. Datensätze in MongoDB zählen
Tahseen Tauseef 15 Februar 2024
MongoDB MongoDB Record
  1. Operationen in MongoDB
  2. Aggregierter Betrieb in MongoDB
  3. $count in MongoDB
  4. db.collection.count() in MongoDB
  5. MongoDB-Gruppe nach Anzahl
  6. MongoDB-Gruppe nach Anzahl sortieren
  7. MongoDB-Gruppe durch Zählen mehrerer Felder
  8. MongoDB-Gruppe nach Datum und Anzahl
  9. .toArray()-Methode in MongoDB
  10. .itcount() in MongoDB
Datensätze in MongoDB zählen

Dieser Artikel behandelt Operatoren in MongoDB, den aggregate-Operator und die verschiedenen Methoden zum Zählen von Gesamtdatensätzen.

Operationen in MongoDB

CRUD-Operationen sind die Konzepte einer Benutzerschnittstelle, die es Benutzern ermöglichen, Objekte in einer Datenbank zu durchsuchen, zu suchen und zu ändern.

MongoDB-Dokumente werden geändert, indem eine Verbindung zu einem Server hergestellt, die entsprechenden Dokumente abgefragt und dann transformiert werden, bevor diese Daten zur Verarbeitung an die Datenbank zurückgesendet werden. CRUD ist ein datengesteuerter Prozess, der HTTP-Aktionsverben verwendet, um ihn zu standardisieren.

  1. Erstellen – wird verwendet, um neue Dokumente in die MongoDB-Datenbank einzufügen.
  2. Lesen - wird verwendet, um ein Dokument in der Datenbank abzufragen.
  3. Aktualisieren - wird verwendet, um bestehende Dokumente in der Datenbank zu ändern.
  4. Löschen - entfernt Dokumente aus der Datenbank.

Aggregierter Betrieb in MongoDB

Es handelt sich um eine Datenverarbeitungsoperation, die aus Phasen besteht, die viele Operationen an gruppierten Daten ausführen, um ein einzelnes Ergebnis zu erzielen. Im Folgenden finden Sie drei Optionen für die Durchführung der Aggregation-Operation.

  1. Pipeline für die Aggregation – Dokumente werden durch eine mehrstufige Pipeline geliefert, die sie in eine Ausgabe integriert. Der MongoDB-Aggregationsprozess ist in mehrere Phasen unterteilt.

    Ein Beispiel ist unten angegeben.

    db.collection_name.aggregate([

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

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

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

])

  2. Einzweck-Aggregationsmethoden – Einzweck-Aggregationsmethoden sind einfach, aber ihnen fehlt die Leistungsfähigkeit einer Aggregat-Pipeline.

  3. Map-Reduce – Map-Reduce-Vorgänge sind seit MongoDB 5.0 veraltet. Verwenden Sie stattdessen eine aggregierte Pipeline.

$count in MongoDB

Sendet ein Dokument mit einer Zählung der Anzahl der empfangenen Datensätze an den nächsten Schritt.

Verhalten:

Die folgende Sequenz $group + $project entspricht der Stufe $count.

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

Wo myCount bedeutet, enthält das Ausgabefeld die Zählung. Sie können dem Ausgabefeld einen anderen Namen geben.

Beispiel:

Eine Sammlung mit dem Namen Partituren enthält die angegebenen Dokumente.

{ "_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 }

Der folgende Aggregationsvorgang besteht aus zwei Phasen.

  1. Die $match-Phase filtert Dokumente mit einem score-Wert von kleiner oder gleich 80 heraus, sodass Dokumente mit einem score von mehr als 80 in die nächste Stufe gehen können.
  2. Der $count-Schritt berechnet die Anzahl der in der aggregierten Pipeline verbleibenden Dokumente und speichert das Ergebnis in einer Variablen namens passing_scores.
db.scores.aggregate(
  [
    {
      $match: {
        score: {
          $gt: 80
        }
      }
    },
    {
      $count: "passing_scores"
    }
  ]
)

Die Operation gibt die folgenden Ergebnisse zurück.

{ "passing_scores" : 4 }

Um 1000 Datensätze zu erhalten, dauert dies im Durchschnitt 2 ms und ist der schnellste Weg.

db.collection.count() in MongoDB

Gibt die Anzahl der Datensätze in der Sammlung oder Ansicht zurück, die mit einer find()-Abfrage übereinstimmen würden. Die Funktion db.collection.count() zählt und liefert die Anzahl der Ergebnisse, die einer Abfrage entsprechen, und nicht die Prozedur find().

Verhalten:

In Transaktionen können Sie weder count noch die Shell-Tools count() und db.collection.count() verwenden.

Gesplitterte Cluster

Wenn verwaiste Dokumente vorhanden sind oder eine Chunk-Migration im Gange ist, kann die Verwendung von db.collection.count() ohne ein Abfrageprädikat auf einem Sharding-Cluster zu einer fehlerhaften Zählung führen.

Verwenden Sie die Funktion db.collection.aggregate() auf einem Sharded-Cluster, um diese Situationen zu vermeiden.

Um die Dokumente zu zählen, verwenden Sie den Schritt $count. Das folgende Verfahren zählt beispielsweise die Dokumente in einer Sammlung.

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

Die Phase $count entspricht der folgenden Sequenz $group + $project.

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

Indexverwendung

Betrachten Sie eine Sammlung mit dem folgenden Index.

{ a: 1, b: 1 }

Bei der Durchführung einer Zählung kann MongoDB den Index nur verwenden, um die Zählung zurückzugeben, wenn die Abfrage:

  1. kann einen Index verwenden,
  2. enthält nur Bedingungen für die Schlüssel des Index, und
  3. prädiziert den Zugriff auf einen einzelnen fortlaufenden Bereich von Indexschlüsseln

Wenn beispielsweise nur der Index angegeben ist, können die folgenden Prozeduren die Anzahl zurückgeben.

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

Angenommen, die Abfrage kann einen Index verwenden, aber die Prädikate erreichen keinen einzigen kontinuierlichen Bereich von Indexschlüsseln. Die Abfrage hat auch Bedingungen für Felder außerhalb des Indexes.

In diesem Fall muss MongoDB die Dokumente lesen und zusätzlich den Index verwenden, um die Anzahl bereitzustellen.

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()

Unter solchen Umständen lagert MongoDB die Dokumente während des ersten Lesevorgangs in den Arbeitsspeicher aus, wodurch die Geschwindigkeit nachfolgender Aufrufe derselben Zähloperation verbessert wird.

Genauigkeit im Falle einer unerwarteten Abschaltung

Die von count() bereitgestellten Zählstatistiken können nach einem unsauberen Herunterfahren eines mongod, der die Wired Tiger-Speicher-Engine verwendet, fehlerhaft sein.

Zwischen dem letzten Prüfpunkt und dem unsauberen Herunterfahren bestimmt die Anzahl der ausgeführten Einfüge-, Aktualisierungs- oder Löschvorgänge das Ausmaß der Drift.

Checkpoints finden im Durchschnitt alle 60 Sekunden statt. mongod-Instanzen mit nicht standardmäßigen -syncdelay-Optionen hingegen können mehr oder weniger Checkpoints haben.

Um die Statistiken nach einem unsauberen Herunterfahren wiederherzustellen, führen Sie validate für jede Sammlung auf dem mongod aus.

Nach unsauberem Herunterfahren:

  1. validate aktualisiert die Zählstatistik in der collStats-Ausgabe mit dem neusten Wert.
  2. Andere Statistiken wie die Anzahl der eingefügten oder entfernten Dokumente in der collStats-Ausgabe sind Schätzungen.

Trennung des Clients

Wenn ab MongoDB 4.2 der Client, der db.collection.count() ausgegeben hat, die Verbindung trennt, bevor die Operation abgeschlossen ist, markiert MongoDB db.collection.count() mit killOp für die Beendigung.

Alle Dokumente in einer Sammlung zählen

Verwenden Sie die folgende Operation, um die Anzahl aller Datensätze in der Sammlung Bestellungen zu zählen.

db.orders.count()

Diese Operation ist äquivalent zu der folgenden.

db.orders.find().count()

Alle Dokumente zählen, die einer Abfrage entsprechen

Zählen Sie, wie viele Dokumente in der Sammlung Bestellungen das Feld ord_dt haben, das grösser ist als neues Datum ('01.01.2012').

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

Die Abfrage entspricht der folgenden.

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

MongoDB-Gruppe nach Anzahl

Der Spalte _id jedes Dokuments in MongoDB wurde eine eindeutige Gruppe nach Wert zugewiesen. Die Aggregattechnik verarbeitet dann die Daten, wodurch berechnete Ergebnisse erzeugt werden.

Das Folgende ist ein Beispiel. Das Datenbank-Setup kann hier eingesehen werden.

Diese Einstellung wird in allen in diesem Artikel vorgestellten Codebeispielen verwendet.

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"
      ]
    }
  ]
}

Die Abfrage für die oben verwendete Datenbank lautet:

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

Der Link für die obige Ausführung wird angegeben, um die Funktionsweise dieses Codesegments zu sehen.

gruppiere nach

MongoDB-Gruppe nach Anzahl sortieren

In diesem Abschnitt wird $sortByCount verwendet, was dasselbe ist wie $group + $sort. Es kann eine Gruppe von Personen in aufsteigender und absteigender Reihenfolge sortieren und zählen.

Eine Beispielabfrage ist unten angegeben. In diesem Beispiel wurden der Datensammlung einige Dokumente hinzugefügt und mit der Methode find() ermittelt, wie viele Einträge sie enthält.

Das Folgende ist die Abfrage für find().

db.data.find()

Sie können auf die Ausführung dieser Abfrage über diesen Link zugreifen.

Der nächste Schritt besteht darin, das Array von Kursen zu rückgängig zu machen und die Funktion $sortByCount zu verwenden, um die Anzahl der zu jedem Kurs hinzugefügten Datensätze zu zählen.

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

Der Link ist hier angegeben, um zu sehen, wie diese Abfrage mit der obigen Datenbankkonfiguration funktioniert. Dies ist der einfachste Ansatz für die MongoDB-Gruppe, indem das Array gezählt und sortiert wird.

Gruppieren um 2

MongoDB-Gruppe durch Zählen mehrerer Felder

Die Funktion aggregate() von MongoDB kann mehrere Felder zählen. Dadurch werden die Felder mit $count gezählt.

Unten ist ein Beispiel, wo ein Zeitstempel nur für einen Eintrag verwendet wird. Einige Dokumente können in diesem Beispiel in der Sammlung student gespeichert werden, und Sie können die Methode find() verwenden, um zu sehen, wie viele Dokumente Sie haben.

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

Die Ausführung dieser Abfrage ist unter diesem Link abrufbar.

MongoDB-Gruppe nach Datum und Anzahl

Wenn Sie ein bestimmtes Datumsdokument zählen müssen, können Sie die Zählaggregation verwenden und ein bestimmtes Datumsdokument zählen.

Hier ist eine Illustration. In diesem Beispiel lernen Sie, den Gesamtverkaufsbetrag und die Anzahl der Verkäufe für jeden Tag im Jahr 2021 zu berechnen.

Sie können die Felder Produkt-ID, Artikelname, Preis, Menge und Datum in die Sammlung Verkäufe aufnehmen. Die Dokumente können mit der Methode find() bezogen werden.

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")
}

Die Abfrage für die obige Konfiguration lautet:

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 }
  }
 ])

Jetzt werden unten Abfragen für ein einzelnes Feld und mehrere Feldgruppen mit den Befehlen count und field gegeben.

  1. Einzelfeld gruppieren nach und zählen

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

  2. Mehrere Felder gruppieren nach und zählen

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

  3. Mehrere Felder gruppieren nach und zählen mit Sortierung nach Feld

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

  4. Mehrere Felder gruppieren nach und zählen mit Sortieren nach Anzahl

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

.toArray()-Methode in MongoDB

Die Funktion toArray() gibt ein Array zurück, das alle Dokumente in einem Cursor enthält. Die Prozedur durchläuft den Cursor viele Male, lädt alle Dokumente in den RAM und erschöpft den Zeiger.

Betrachten Sie das folgende Beispiel, das die Funktion toArray() verwendet, um den von der Methode find() zurückgegebenen Cursor umzuwandeln.

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

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

Die Variable allProductsArray enthält das von toArray() zurückgegebene Array von Dokumenten. Um 1000 Datensätze zu erhalten, dauert dies im Durchschnitt 18 ms.

.itcount() in MongoDB

Zählt, wie viele Dokumente in einem Cursor verbleiben.

itcount() ist ähnlich wie cursor.count(), aber anstatt die Abfrage auf einem neuen Iterator auszuführen, führt es sie auf einem bestehenden aus und erschöpft seinen Inhalt.

Die Prototypform der itcount()-Methode sieht wie folgt aus.

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

Um 1000 Datensätze zu erhalten, dauert dies im Durchschnitt 14 ms.

In diesem Artikel wurden die Operationen im Detail besprochen, und die Operation Aggregation wurde ebenfalls besprochen. Zunächst wurden verschiedene Arten von Aggregatfunktionen mit Codesegmenten kurz besprochen.

Dann wurde Gruppieren nach und das Zählen besprochen, wobei Sortieren, Finden und Mehrfachfelder besprochen wurden. Dann werden verschiedene Möglichkeiten zum Zählen der Datensätze in MongoDB diskutiert.

Verwandter Artikel - MongoDB Record