प्रत्येक दिन का अंतिम रिकॉर्ड खोजें

मूल उत्तर से थोड़ा अधिक आधुनिक:

db.collection.aggregate([
  { "$sort": { "date": 1 } },
  { "$group": {
    "_id": {
      "$subtract": ["$date",{"$mod": ["$date",86400000]}]
    },
    "doc": { "$last": "$$ROOT" }
  }},
  { "$replaceRoot": { "newDocument": "$doc" } }
])

यही सिद्धांत लागू होता है कि आप अनिवार्य रूप से $sort संग्रह और फिर $group आवश्यक ग्रुपिंग कुंजी पर $last समूहीकरण सीमा से डेटा।

चीजों को थोड़ा स्पष्ट करना क्योंकि मूल लेखन यह है कि आप $$ROOT . का उपयोग कर सकते हैं प्रत्येक दस्तावेज़ संपत्ति को निर्दिष्ट करने के बजाय, और निश्चित रूप से $replaceRoot चरण आपको उस डेटा को मूल दस्तावेज़ के रूप में पूरी तरह से पुनर्स्थापित करने की अनुमति देता है।

लेकिन सामान्य समाधान अभी भी $sort है पहले, फिर $group आवश्यक सामान्य कुंजी पर और $last<रखें /कोड> या $first आवश्यक गुणों के लिए समूहीकरण सीमा से क्रमबद्ध क्रम की घटनाओं पर निर्भर करता है।

 
 प्रश्न के अनुसार टाइमस्टैम्प मान के विपरीत बीएसओएन तिथियों के लिए, समूह परिणाम 15 मिनट के अंतराल पर देखें MongoDb में
 वास्तव में बीएसओएन दिनांक मानों का उपयोग करके और वापस करने के लिए अलग-अलग समय अंतराल के लिए कैसे संचित किया जाए, इस पर विभिन्न दृष्टिकोणों के लिए।
 
 निश्चित नहीं है कि आप यहाँ क्या करने जा रहे हैं, लेकिन अगर मेरी समझ सही है तो आप इसे कुल मिलाकर कर सकते हैं। इसलिए प्रत्येक दिन का अंतिम रिकॉर्ड प्राप्त करने के लिए:
 db.collection.aggregate([
    // Sort in date order  as ascending
    {"$sort": { "date": 1 } },

    // Date math converts to whole day
    {"$project": {
        "adco": 1,
        "hchc": 1,
        "hchp": 1,
        "hhphc": 1,
        "ptec": 1,
        "iinst": 1,
        "papp": 1,
        "imax": 1,
        "optarif": 1,
        "isousc": 1,
        "motdetat": 1,
        "date": 1,
        "wholeDay": {"$subtract": ["$date",{"$mod": ["$date",86400000]}]} 
    }},

    // Group on wholeDay ( _id insertion is monotonic )
    {"$group": 
        "_id": "$wholeDay",
        "docId": {"$last": "$_id" },
        "adco": {"$last": "$adco" },
        "hchc": {"$last": "$hchc" },
        "hchp": {"$last": "$hchp" },
        "hhphc": {"$last": "$hhphc" },
        "ptec": {"$last": "$ptec" },
        "iinst": {"$last": "$iinst" },
        "papp": {"$last": "$papp" },
        "imax": {"$last": "$imax" },
        "optarif": {"$last": "$optarif",
        "isousc": {"$last": "$isouc" },
        "motdetat": {"$last": "$motdetat" },
        "date": {"$last": "$date" },
    }}
])
 
 तो यहां सिद्धांत यह है कि टाइमस्टैम्प मान दिया गया है, प्रत्येक दिन की शुरुआत में मध्यरात्रि समय के रूप में प्रोजेक्ट करने के लिए दिनांक गणित करें। फिर _id . के रूप में दस्तावेज़ पर कुंजी पहले से ही मोनोटोनिक (हमेशा बढ़ती हुई) है, फिर बस पूरे दिन पर समूह बनाएं $last . खींचते समय मान समूह सीमा से दस्तावेज़।
 
 यदि आपको सभी क्षेत्रों की आवश्यकता नहीं है तो केवल प्रोजेक्ट करें और उन पर समूह बनाएं जिन्हें आप चाहते हैं।
 
 और हाँ आप इसे वसंत डेटा ढांचे में कर सकते हैं। मुझे यकीन है कि वहां एक लपेटा हुआ आदेश है। लेकिन अन्यथा, देशी कमांड को प्राप्त करने का मंत्र कुछ इस प्रकार है:
 mongoOps.getCollection("yourCollection").aggregate( ... )
 
 रिकॉर्ड के लिए, यदि आपके पास संख्या के रूप में टाइमस्टैम्प के बजाय वास्तव में BSON दिनांक प्रकार थे, तो आप दिनांक गणित को छोड़ सकते हैं:
 db.collection.aggregate([
    { "$group": { 
        "_id": { 
            "year": { "$year": "$date" },
            "month": { "$month": "$date" },
            "day": { "$dayOfMonth": "$date" }
        },
        "hchp": { "$last": "$hchp" }
    }}
])