Czy MongoDB ' s $in clause guarantee order

Inny sposób przy użyciu zapytania Agregacyjnego tylko dla MongoDB verion >= 3.4 -

Podziękowania należą się temu ładnemu wpisowi na blogu.

Przykładowe dokumenty do pobrania w tej kolejności -

var order = [ "David", "Charlie", "Tess" ];

Zapytanie-

var query = [
             {$match: {name: {$in: order}}},
             {$addFields: {"__order": {$indexOfArray: [order, "$name" ]}}},
             {$sort: {"__order": 1}}
            ];

var result = db.users.aggregate(query);

Kolejny cytat z postu wyjaśniającego użyte operatory agregacji -

Etap "$addFields "jest nowy w 3.4 i pozwala na "$ project " nowe pola do istniejących dokumentów bez wiedzy wszystkie inne istniejące pola. Nowe wyrażenie "$indexOfArray " Zwraca pozycję danego elementu w podanej tablicy.

Zasadniczo operator addFields dodaje nowe pole order do każdego dokumentu, gdy je znajdzie, a to pole order reprezentuje pierwotną kolejność naszej tablicy, którą podaliśmy. Następnie po prostu sortujemy dokumenty na podstawie tego pola.

Jeśli nie chcesz używać aggregate, Innym rozwiązaniem jest użycie find, a następnie posortowanie wyników doc po stronie klienta za pomocą array#sort:

Jeśli wartości $in są typami prymitywnymi, takimi jak liczby, możesz użyć podejścia takiego jak:

var ids = [4, 2, 8, 1, 9, 3, 5, 6];
MyModel.find({ _id: { $in: ids } }).exec(function(err, docs) {
    docs.sort(function(a, b) {
        // Sort docs by the order of their _id values in ids.
        return ids.indexOf(a._id) - ids.indexOf(b._id);
    });
});

Jeśli wartości $in są nie-prymitywnymi typami, takimi jak ObjectId s, wymagane jest inne podejście, ponieważ indexOf porównuje się przez odniesienie w tym przypadku.

Jeśli używasz Node.js 4.x+, możesz użyć Array#findIndex oraz ObjectID#equals do obsługi to przez zmianę funkcji sort na:

docs.sort((a, b) => ids.findIndex(id => a._id.equals(id)) - 
                    ids.findIndex(id => b._id.equals(id)));

Lub z dowolnym węzłem.wersja js z podkreśleniem / lodash ' S findIndex:

docs.sort(function (a, b) {
    return _.findIndex(ids, function (id) { return a._id.equals(id); }) -
           _.findIndex(ids, function (id) { return b._id.equals(id); });
});

Podobnie jak rozwiązanie JonnyHK , możesz zmienić kolejność dokumentów zwróconych z find w swoim kliencie (jeśli twój Klient jest w JavaScript) za pomocą kombinacji map i Array.prototype.find w EcmaScript 2015:

Collection.find({ _id: { $in: idArray } }).toArray(function(err, res) {

    var orderedResults = idArray.map(function(id) {
        return res.find(function(document) {
            return document._id.equals(id);
        });
    });

});

Kilka uwag:

• powyższy kod używa sterownika węzła Mongo i Nie Mongoose
• idArray jest tablicą ObjectId
• nie testowałem wydajności tej metody vs sort, ale jeśli trzeba manipulować każdy zwracany element (co jest dość powszechne) można to zrobić w wywołaniu zwrotnym map, aby uprościć kod.

Wiem, że to pytanie jest związane z Mongoose js framework, ale zduplikowany jeden jest ogólny, więc mam nadzieję, że umieszczenie rozwiązania Python (PyMongo) jest w porządku tutaj.

things = list(db.things.find({'_id': {'$in': id_array}}))
things.sort(key=lambda thing: id_array.index(thing['_id']))
# things are now sorted according to id_array order

Łatwym sposobem na zamówienie wyniku po zwróceniu tablicy mongo jest utworzenie obiektu z id jako kluczami, a następnie mapowanie nad podanymi _idami, aby zwrócić tablicę, która jest prawidłowo uporządkowana.

async function batchUsers(Users, keys) {
  const unorderedUsers = await Users.find({_id: {$in: keys}}).toArray()
  let obj = {}
  unorderedUsers.forEach(x => obj[x._id]=x)
  const ordered = keys.map(key => obj[key])
  return ordered
}

Zawsze? Nigdy. Kolejność jest zawsze taka sama: undefined(prawdopodobnie fizyczna kolejność, w jakiej przechowywane są dokumenty). Chyba, że to rozwiążesz.

Wiem, że to stary wątek, ale jeśli zwracasz tylko wartość Id w tablicy, być może będziesz musiał wybrać tę składnię. Ponieważ nie mogłem uzyskać wartości indexOf pasującej do formatu Mongo ObjectId.

  obj.map = function() {
    for(var i = 0; i < inputs.length; i++){
      if(this._id.equals(inputs[i])) {
        var order = i;
      }
    }
    emit(order, {doc: this});
  };

Jak przekonwertować Mongo ObjectId .toString bez włączania wrappera' ObjectId ()' -- tylko wartość?

Możesz zagwarantować zamówienie za pomocą klauzuli $or.

Więc użyj $or: [ _ids.map(_id => ({_id}))] zamiast.

Jest to rozwiązanie kodu po pobraniu wyników z Mongo. Używanie mapy do przechowywania indeksu, a następnie Zamiana wartości.

catDetails := make([]CategoryDetail, 0)
err = sess.DB(mdb).C("category").
    Find(bson.M{
    "_id":       bson.M{"$in": path},
    "is_active": 1,
    "name":      bson.M{"$ne": ""},
    "url.path":  bson.M{"$exists": true, "$ne": ""},
}).
    Select(
    bson.M{
        "is_active": 1,
        "name":      1,
        "url.path":  1,
    }).All(&catDetails)

if err != nil{
    return 
}
categoryOrderMap := make(map[int]int)

for index, v := range catDetails {
    categoryOrderMap[v.Id] = index
}

counter := 0
for i := 0; counter < len(categoryOrderMap); i++ {
    if catId := int(path[i].(float64)); catId > 0 {
        fmt.Println("cat", catId)
        if swapIndex, exists := categoryOrderMap[catId]; exists {
            if counter != swapIndex {
                catDetails[swapIndex], catDetails[counter] = catDetails[counter], catDetails[swapIndex]
                categoryOrderMap[catId] = counter
                categoryOrderMap[catDetails[swapIndex].Id] = swapIndex
            }
            counter++
        }
    }
}