MongoDB: Wyszukaj minimum, maksimum w obiekcie zagnieżdżonym z nazwą pola dynamicznego

Question

Mam zapytanie, aby uzyskać minimum query i maximum query poniżej zestawu danych próbki. W moim przypadku pól nazwy są dynamiczne, jak poniżej product_1, product_2 ...

{ 
    "_id" : NumberLong(540), 
    "product_1" : { 
      "orderCancelled" : 0, 
      "orderDelivered" : 6 
    }, 
    "product_2" : { 
      "orderCancelled" : 3, 
      "orderDelivered" : 16 
    }, 
    "product_3" : { 
      "orderCancelled" : 5, 
      "orderDelivered" : 11 
    } 
} 

nie otrzymuję pomysł jak mogę to zrobić w Mongo, gdzie nazwy pól są dynamiczne, czyli w przyszłości może być inna produkty są również tworzone jako product_4 i product_5 dla tego samego id.

muszę zapytać, co dało mi minimalną wartość orderDelivered i maksymalną wartość dla orderCancelled, jak na przykład w wyniku wyżej dokument zostanie orderDelivered:16 & orderCancelled:0.
Dzięki za każdy pomysł.

Answer 1

Należy zrestrukturyzować swój dokument tak, że wszystkie dokumenty są w produktach tablicy:

{ 
    "_id": NumberLong(540), 
    products: [ 
     { 
      "name": "product_1", 
      "orderCancelled": 0, 
      "orderDelivered": 6 
     }, 
     { 
      "name": "product_2", 
      "orderCancelled": 3, 
      "orderDelivered": 16 
     }, 
     { 
      "name": "product_3", 
      "orderCancelled": 5, 
      "orderDelivered": 11 
     } 
    ] 
} 

Wtedy będziesz w stanie wydawać normalne max/min zapytań tak:

db.test.aggregate([ 
    { 
     $match: { "_id" : NumberLong(540) } 
    }, 
    { 
     $unwind: "$products" 
    }, 
    { 
     $group: { 
      _id: "$_id", 
      minDelivered: { $min: "$products.orderDelivered" }, 
      maxCancelled: { $max: "$products.orderCancelled" } 
     } 
    } 
]) 

Answer 2

You trzeba zmienić strukturę dokumentów, aktualizując je. Będziesz potrzebował przechodzić przez każdy dokument, używając metody .forEach, a następnie $unset nazwy wszystkich pól, które zaczynają się od product_. Tam musisz dodać nowe pola products, które są tablicą produktów przy użyciu operatora aktualizacji $set. Mając na uwadze powyższe należy użyć "bulk" operacji zaktualizować dokumenty dla maksymalnej wydajności

var bulkOp = db.collection.initializeOrderedBulkOp(); 
var count = 0; 
db.collection.find().forEach(function(doc) { 
    var allproducts = []; 
    for(var key in doc) { 
     if(Object.prototype.hasOwnProperty.call(doc, key) && /^product_\d+/.test(key)) { 
      var product = {}; 
      product["name"] = key;  
      product["orderCancelled"] = doc[key]["orderCancelled"]; 
      product["orderDelivered"] = doc[key]["orderDelivered"]; 
      allproducts.push(product); 
      var unsetField = {}; 
      unsetField[key] = ""; 
      bulkOp.find({"_id": doc._id}).update({ "$unset": unsetField }); 
     }; 
     count++; 
    }; 
    bulkOp.find({"_id": doc._id}).update({ 
     "$set": { "products": allproducts } 
    }); 
    count++; 
    if(count % 500 === 0) { 
     // Execute per 500 operations and re-init 
     bulkOp.execute(); 
     bulkOp = db.collection.initializeOrderedBulkOp(); 
    } 
}) 

// clean up queues 

if(count > 0) { 
    bulkOp.execute(); 
} 

Twoje dokumenty będą teraz wyglądać następująco:

{ 
     "_id" : NumberLong(542), 
     "products" : [ 
       { 
         "name" : "product_1", 
         "orderCancelled" : 0, 
         "orderDelivered" : 6 
       }, 
       { 
         "name" : "product_2", 
         "orderCancelled" : 3, 
         "orderDelivered" : 16 
       }, 
       { 
         "name" : "product_3", 
         "orderCancelled" : 5, 
         "orderDelivered" : 11 
       } 
     ] 
} 

Potem przychodzi zapytanie agregacji za pomocą metody .aggregate():

db.collection.aggregate([ 
    { "$match": { "_id": 542 } }, 
    { "$unwind": "$products" }, 
    { "$group": { 
     "_id": "$_id", 
     "maxOrderCancelled": { "$max": "$products.orderCancelled"}, 
     "minOrderDelivvered": { "$min": "$products.orderDelivered"} 
    }} 
]) 

Co zwraca:

{ "_id" : NumberLong(542), "maxOrderCancelled" : 5, "minOrderDelivvered" : 6 } 

Od version 3.2 można użyć $max i $min w etapie $project który jest o wiele bardziej lepszy sposób to zrobić, ponieważ nie ma potrzeby $unwind pierwszej tablicy.

db.collection.aggregate([ 
    { "$match": { "_id": 542 } }, 
    { "$project": { 
     "maxOrderCancelled": { 
      "$max": { 
       "$map": { 
        "input": "$products", 
        "as": "order", 
        "in": "$$orc.orderCancelled" 
       } 
      } 
     }, 
     "minOrderDelivered": { 
      "$min": { 
       "$map": { 
        "input": "$products", 
        "as": "orc", 
        "in": "$$orc.orderDelivered" 
       } 
      } 
     } 
    }} 
]) 

co daje:

{ "_id" : NumberLong(542), "maxOrderCancelled" : 5, "minOrderDelivered" : 6 }