Mungo Limit / Offset und Count Abfrage

Etwas seltsam in Bezug auf die Abfrageleistung ... Ich muss eine Abfrage ausführen, die eine Gesamtanzahl von Dokumenten ausführt und auch eine Ergebnismenge zurückgeben kann, die begrenzt und versetzt werden kann.

Ich habe also insgesamt 57 Dokumente und der Benutzer möchte 10 Dokumente, die um 20 versetzt sind.

Ich kann mir zwei Möglichkeiten vorstellen, dies zu tun: Zuerst werden alle 57 Dokumente abgefragt (als Array zurückgegeben) und dann mit array.slice die gewünschten Dokumente zurückgegeben. Die zweite Option besteht darin, zwei Abfragen auszuführen, die erste mit der nativen 'count'-Methode von mongo, und dann eine zweite Abfrage mit den nativen Aggregatoren $ limit und $ skip von mongo auszuführen.

Was denkst du würde besser skalieren? Alles in einer Abfrage erledigen oder zwei separate ausführen?

Bearbeiten:

// 1 query
var limit = 10;
var offset = 20;

Animals.find({}, function (err, animals) {
    if (err) {
        return next(err);
    }

    res.send({count: animals.length, animals: animals.slice(offset, limit + offset)});
});


// 2 queries
Animals.find({}, {limit:10, skip:20} function (err, animals) {            
    if (err) {
        return next(err);
    }

    Animals.count({}, function (err, count) {
        if (err) {
            return next(err);
        }

        res.send({count: count, animals: animals});
    });
});

Ich schlage vor, 2 Abfragen zu verwenden:

1. db.collection.count()gibt die Gesamtzahl der Artikel zurück. Dieser Wert wird irgendwo in Mongo gespeichert und nicht berechnet.

2. db.collection.find().skip(20).limit(10)Hier gehe ich davon aus, dass Sie eine Sortierung nach einem Feld verwenden können. Vergessen Sie also nicht, einen Index für dieses Feld hinzuzufügen. Diese Abfrage wird auch schnell sein.

Ich denke, dass Sie nicht alle Elemente abfragen und dann überspringen und nehmen sollten, da Sie später, wenn Sie über große Datenmengen verfügen, Probleme mit der Datenübertragung und -verarbeitung haben werden.

Anstatt zwei separate Abfragen zu verwenden, können Sie diese aggregate()in einer einzigen Abfrage verwenden:

Aggregierte "$ facet" können schneller abgerufen werden, die Gesamtzahl und die Daten mit Skip & Limit

    db.collection.aggregate([

      //{$sort: {...}}

      //{$match:{...}}

      {$facet:{

        "stage1" : [ {"$group": {_id:null, count:{$sum:1}}} ],

        "stage2" : [ { "$skip": 0}, {"$limit": 2} ]
  
      }},
     
     {$unwind: "$stage1"},
  
      //output projection
     {$project:{
        count: "$stage1.count",
        data: "$stage2"
     }}

 ]);

Ausgabe wie folgt: -

[{
     count: 50,
     data: [
        {...},
        {...}
      ]
 }]

Besuchen Sie auch https://docs.mongodb.com/manual/reference/operator/aggregation/facet/

Nachdem ich dieses Problem selbst angehen musste, möchte ich auf der Antwort von user854301 aufbauen.

Mungo ^ 4.13.8 Ich konnte eine aufgerufene Funktion verwenden, mit toConstructor()der ich vermeiden konnte, die Abfrage mehrmals zu erstellen, wenn Filter angewendet werden. Ich weiß, dass diese Funktion auch in älteren Versionen verfügbar ist, aber Sie müssen die Mongoose-Dokumente überprüfen, um dies zu bestätigen.

Das Folgende verwendet Bluebird-Versprechen:

let schema = Query.find({ name: 'bloggs', age: { $gt: 30 } });

// save the query as a 'template'
let query = schema.toConstructor();

return Promise.join(
    schema.count().exec(),
    query().limit(limit).skip(skip).exec(),

    function (total, data) {
        return { data: data, total: total }
    }
);

Jetzt gibt die Zählabfrage die Gesamtzahl der übereinstimmenden Datensätze zurück und die zurückgegebenen Daten sind eine Teilmenge der Gesamtzahl der Datensätze.

Bitte beachten Sie das () um query (), das die Abfrage erstellt.

Es gibt eine Bibliothek, die all dies für Sie erledigt. Schauen Sie sich mongoose-paginate-v2 an

db.collection_name.aggregate([
    { '$match'    : { } },
    { '$sort'     : { '_id' : -1 } },
    { '$facet'    : {
        metadata: [ { $count: "total" } ],
        data: [ { $skip: 1 }, { $limit: 10 },{ '$project' : {"_id":0} } ] // add projection here wish you re-shape the docs
    } }
] )

Anstatt zwei Abfragen zu verwenden, um die Gesamtzahl zu ermitteln und den übereinstimmenden Datensatz zu überspringen.
$ facet ist der beste und optimierte Weg.

1. Passen Sie den Datensatz an
   
2. Finde total_count
   
3. Überspringen Sie die Aufzeichnung
   
4. Und kann auch Daten entsprechend unseren Anforderungen in der Abfrage umformen.