Zapytanie o limit / przesunięcie i licznik Mongoose

Trochę dziwne pytanie o wydajność zapytania ... Muszę uruchomić zapytanie, które oblicza całkowitą liczbę dokumentów i może również zwrócić zestaw wyników, który można ograniczyć i przesunąć.

Mam więc w sumie 57 dokumentów, a użytkownik chce, aby 10 dokumentów zostało przesuniętych o 20.

Przychodzą mi do głowy 2 sposoby na zrobienie tego, najpierw zapytanie o wszystkie 57 dokumentów (zwrócone jako tablica), a następnie użycie array.slice zwróci żądane dokumenty. Drugą opcją jest uruchomienie 2 zapytań, pierwszego przy użyciu natywnej metody „count” mongo, a następnie uruchomienie drugiego zapytania przy użyciu natywnych agregatorów $ limit i $ skip mongo.

Jak myślisz, które będzie lepiej skalowane? Robisz to wszystko w jednym zapytaniu lub uruchamiasz dwa oddzielne?

Edytować:

// 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});
    });
});

Proponuję użyć 2 zapytań:

1. db.collection.count()zwróci całkowitą liczbę elementów. Ta wartość jest przechowywana gdzieś w Mongo i nie jest obliczana.

2. db.collection.find().skip(20).limit(10)tutaj zakładam, że możesz użyć sortowania według jakiegoś pola, więc nie zapomnij dodać indeksu do tego pola. To zapytanie też będzie szybkie.

Myślę, że nie powinieneś odpytywać wszystkich pozycji, a następnie wykonać pomiń i weź, bo później, gdy będziesz mieć duże zbiory danych, będziesz miał problemy z przesyłaniem i przetwarzaniem danych.

Zamiast używać dwóch oddzielnych zapytań, możesz użyć aggregate()w jednym zapytaniu:

Zagregowane „$ facet” można pobrać szybciej, całkowitą liczbę i dane z pominięciem i ograniczeniem

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

 ]);

wyjście w następujący sposób: -

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

Zajrzyj również na https://docs.mongodb.com/manual/reference/operator/aggregation/facet/

Po samodzielnym rozwiązaniu tego problemu chciałbym skorzystać z odpowiedzi użytkownika854301.

Mongoose ^ 4.13.8 Udało mi się użyć funkcji o nazwie, toConstructor()która pozwoliła mi uniknąć wielokrotnego budowania zapytania po zastosowaniu filtrów. Wiem, że ta funkcja jest również dostępna w starszych wersjach, ale musisz sprawdzić dokumentację Mongoose, aby to potwierdzić.

Poniższe wykorzystuje obietnice Bluebird:

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

Teraz zapytanie zliczające zwróci całkowitą liczbę dopasowanych rekordów, a zwrócone dane będą podzbiorem wszystkich rekordów.

Zwróć uwagę na () wokół query (), które konstruuje zapytanie.

Jest biblioteka, która zrobi to wszystko za Ciebie, sprawdź mongoose-paginate-v2

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

Zamiast używać dwóch zapytań, aby znaleźć całkowitą liczbę i pominąć dopasowany rekord.
$ facet to najlepszy i zoptymalizowany sposób.

1. Dopasuj rekord
   
2. Znajdź total_count
   
3. pomiń zapis
   
4. A także może zmienić kształt danych zgodnie z naszymi potrzebami w zapytaniu.