Rufen Sie die Anzahl der Elemente für jedes Datum im MongoDB-Aggregat ab

Frageninhalt

Ich habe eine Sammlung mit Ereignissen. Jedes Ereignis verfügt über einen millisekundengenauen Zeitstempel. Ich möchte tägliche Ereignisse gruppieren. Zum Beispiel:

Ich habe

key       value

_id       111222333444555ddd666fff
time      2023-04-23t15:35:19.631z
type      pizza-event

_id       111222333444555ddd666fff
time      2023-04-23t01:41:20.631z
type      tv-event

_id       111222333444555ddd666fff
time      2023-04-22t05:00:05.631z
type      some-event

Das tue ich

key        value

date       04-22-2023
count      1.0

date       04-23-2023
count      2.0

Das ultimative Ziel ist die Verwendung von Abfragen in Golang-Projekten.

Bisher habe ich

[
        {
            "$match" : {
                "$and" : [
                    {
                        "type" : "foo.bar.event"
                    },
                    {
                        "time" : {
                            "$gte" : isodate("2023-04-23t00:00:00.000+0000")
                        }
                    },
                    {
                        "time" : {
                            "$lte" : isodate("2023-04-25t00:00:00.000+0000")
                        }
                    }
                ]
            }
        }, 
        {
            "$group" : {
                "_id" : {
                    "$datetostring" : {
                        "format" : "%m-%d-%y",
                        "date" : "$time"
                    }
                },
                "count" : {
                    "$sum" : 1.0
                }
            }
        }
    ]

Rückkehr

key            value

_id            04-24-2023
count          476.0

_id            04-23-2023
count          28.0

Das sollte funktionieren, aber wenn ich diese Abfrage in meinem Go-Projekt schreibe, erscheint unter „$datetostring“ eine rote, verschnörkelte Linie mit der Meldung „Ungültiger Feldname“, idealerweise hätte ich gerne einen „Uhrzeit“-Schlüssel für das Datum statt „_id“. Als ich während der Gruppenphase folgende Änderungen vorgenommen habe:

{
    _id: null,
    "date": {"$dateToString": { "format": "%m-%d-%Y", "date": "$time"}},
    "count": {"$sum": 1}
}

Ich erhalte die Fehlermeldung „$datetostring“, dass der Gruppenoperator unbekannt ist. Also dachte ich darüber nach, die Gruppe zu erstellen und dann eine Elementstufe für „$datetostring“ hinzuzufügen, aber jetzt gibt die Gruppenstufe die Gruppe jede Millisekunde zurück, was den Zweck der Gruppierung zunichte macht.

Mir ist klar, dass ich zwei verschiedene Themen bespreche. Obwohl jede Hilfe großartig wäre, geht es bei dieser Frage speziell um die Behebung von Mongo-Abfragen. Ich werde bei Bedarf in einem anderen Thread auf die Golang-Codierung zurückkommen. Wenn ich es klarer machen kann, lassen Sie es mich bitte wissen.

Richtige Antwort

Zuallererst: Wenn Sie über eine Anwendungs-Benutzeroberfläche zum Anzeigen der Abfrageergebnisse verfügen, müssen Sie sich nicht um die Formatierung der Ausgabe in der Abfrage kümmern. Dies liegt in der Verantwortung der Anwendungs-UI. Übrigens: Wenn Sie eine App-Benutzeroberfläche haben, sollten Sie die Verwendung von $datetrunc 而不是 $datetostring in Betracht ziehen.

Wie auch immer, in Bezug auf die Anforderungen in Ihrer Frage sollte eine $project Phase wie diese für Sie funktionieren:

[
  {
    "$group": {
      "_id": {
        "$datetostring": { "date": "$time", "format": "%m-%d-%y" }
      },
      "count": { "$sum": 1 }
    }
  },
  { "$project": { "_id": 0, "time": "$_id", "count": "$count" } }
]

Mongodb-Shell-Ausgabe:

{ "time" : "02-08-2020", "count" : 2 }
{ "time" : "05-18-2020", "count" : 2 }
{ "time" : "03-20-2021", "count" : 3 }
{ "time" : "01-11-2021", "count" : 1 }

Zur Verwendung von Abfragen in Go-Projekten finden Sie hier eine Demo:

package main

import (
    "context"
    "fmt"
    "time"

    "go.mongodb.org/mongo-driver/bson"
    "go.mongodb.org/mongo-driver/mongo"
    "go.mongodb.org/mongo-driver/mongo/options"
)

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
    defer cancel()
    client, err := mongo.Connect(ctx, options.Client().ApplyURI("mongodb://localhost:27017"))
    if err != nil {
        panic(err)
    }

    coll := client.Database("baz").Collection("cakeSales")

    matchStage := bson.D{
        {"$match", bson.D{
            {"$and", []bson.D{
                {{"time", bson.D{
                    {"$gte", time.Date(2019, 6, 1, 0, 0, 0, 0, time.UTC)},
                }}},
                {{"time", bson.D{
                    {"$lte", time.Date(2021, 2, 1, 0, 0, 0, 0, time.UTC)},
                }}},
            }},
        }},
    }

    groupStage := bson.D{
        {"$group", bson.D{
            {"_id", bson.D{
                {"$dateToString", bson.D{
                    {"date", "$time"},
                    {"format", "%m-%d-%Y"},
                }},
            }},
            {"count", bson.D{
                {"$sum", 1},
            }},
        }},
    }

    projectStage := bson.D{
        {"$project", bson.D{
            {"_id", 0},
            {"time", "$_id"},
            {"count", "$count"},
        }},
    }

    cursor, err := coll.Aggregate(context.TODO(),
        mongo.Pipeline{matchStage, groupStage, projectStage})
    if err != nil {
        panic(err)
    }

    var results []bson.M
    if err = cursor.All(context.TODO(), &results); err != nil {
        panic(err)
    }
    for _, result := range results {
        fmt.Printf(
            "time: %s count: %v\n",
            result["time"],
            result["count"])
    }
}

Das obige ist der detaillierte Inhalt vonRufen Sie die Anzahl der Elemente für jedes Datum im MongoDB-Aggregat ab. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!