मोंगोडीबी सॉर्ट बनाम एरे इंडेक्स पर कुल $ सॉर्ट

एकत्रीकरण ढांचा उसी तरह से सरणियों के साथ "डील" नहीं करता है जैसा कि .find() पर लागू होता है। सामान्य रूप से प्रश्न। यह केवल .sort() . जैसे संचालनों के लिए ही सही नहीं है , लेकिन अन्य ऑपरेटरों के साथ भी, और अर्थात् $slice कोड> , हालांकि वह उदाहरण ठीक होने वाला है (अधिक बाद में)।

तो आपके पास एक सरणी स्थिति की अनुक्रमणिका के साथ "डॉट नोटेशन" फॉर्म का उपयोग करके किसी भी चीज़ से निपटना असंभव है। लेकिन इसके लिए एक रास्ता है।

आप जो "कर सकते हैं" वह मूल रूप से यह निर्धारित करता है कि "nth" सरणी तत्व वास्तव में एक मान के रूप में क्या है, और फिर उसे एक फ़ील्ड के रूप में वापस करें जिसे सॉर्ट किया जा सकता है:

  db.test.aggregate([
    { "$unwind": "$items" },
    { "$group": { 
      "_id": "$_id",
      "items": { "$push": "$items" },
      "itemsCopy":  { "$push": "$items" },
      "first": { "$first": "$items" }
    }},
    { "$unwind": "$itemsCopy" },
    { "$project": {
      "items": 1,
      "itemsCopy": 1,
      "first": 1,
      "seen": { "$eq": [ "$itemsCopy", "$first" ] }
    }},
    { "$match": { "seen": false } },
    { "$group": {
      "_id": "$_id",
      "items": { "$first": "$items" },
      "itemsCopy": { "$push": "$itemsCopy" },
      "first": { "$first": "$first" },
      "second": { "$first": "$itemsCopy" }
    }},
    { "$sort": { "second": -1 } }
  ])

यह एक भयानक और "पुनरावर्तनीय" दृष्टिकोण है जहां आप अनिवार्य रूप से प्रत्येक सरणी तत्व को $first $unwind . फिर $unwind . के बाद फिर से, आप यह देखने के लिए परीक्षण करते हैं कि क्या वह सरणी तत्व वही हैं जो पहले से पहचाने गए सरणी पदों से "देखे गए" हैं।

यह भयानक है, और अधिक पदों के लिए आप आगे बढ़ना चाहते हैं, लेकिन यह परिणाम प्राप्त करता है:

{ "_id" : 2, "items" : [ 0, 3, 4 ], "itemsCopy" : [ 3, 4 ], "first" : 0, "second" : 3 }
{ "_id" : 1, "items" : [ 1, 2, 0 ], "itemsCopy" : [ 2, 0 ], "first" : 1, "second" : 2 }
{ "_id" : 3, "items" : [ 2, 1, 5 ], "itemsCopy" : [ 1, 5 ], "first" : 2, "second" : 1 }

सौभाग्य से, MongoDB की आगामी रिलीज़ (जैसा कि वर्तमान में विकास रिलीज़ में उपलब्ध है) को इसके लिए "फिक्स" मिलता है। हो सकता है कि यह "सही" समाधान न हो जो आप चाहते हैं, लेकिन यह मूल समस्या को हल करता है।

एक नया $slice है वहाँ एकत्रीकरण ढांचे के लिए उपलब्ध ऑपरेटर, और यह अनुक्रमित पदों से सरणी के आवश्यक तत्व (ओं) को वापस कर देगा:

  db.test.aggregate([
    { "$project": {
      "items": 1,
      "slice": { "$slice": [ "$items",1,1 ] }
    }},
    { "$sort": { "slice": -1 } }
  ])

जो उत्पादन करता है:

{ "_id" : 2, "items" : [ 0, 3, 4 ], "slice" : [ 3 ] }
{ "_id" : 1, "items" : [ 1, 2, 0 ], "slice" : [ 2 ] }
{ "_id" : 3, "items" : [ 2, 1, 5 ], "slice" : [ 1 ] }

तो आप नोट कर सकते हैं कि "स्लाइस" के रूप में, परिणाम अभी भी एक "सरणी" है, हालांकि $sort एकत्रीकरण ढांचे में सामग्री को क्रमबद्ध करने के लिए हमेशा सरणी की "पहली स्थिति" का उपयोग किया जाता है। इसका मतलब है कि अनुक्रमित स्थिति से निकाले गए एकवचन मूल्य के साथ (जैसा कि ऊपर की लंबी प्रक्रिया है) तो परिणाम आपकी अपेक्षा के अनुसार क्रमबद्ध किया जाएगा।

यहां अंतिम मामले हैं कि यह कैसे काम करता है। या तो सरणी की अनुक्रमित स्थिति के साथ काम करने के लिए ऊपर से आवश्यक संचालन के साथ रहें, या "प्रतीक्षा करें" जब तक कि एक नया चमकदार संस्करण बेहतर ऑपरेटरों के साथ आपके बचाव में न आ जाए।