MongoDB
 sql >> डेटाबेस >  >> NoSQL >> MongoDB

डायनेमिक कुंजी को कैसे क्वेरी करें - मोंगोडब स्कीमा डिज़ाइन

MongoDB 3.4.4 और नए संस्करणों का उपयोग करना:

db.coll.aggregate([
    { "$replaceRoot": {
        "newRoot": {
            "$arrayToObject": {
                "$filter": {
                    "input": { "$objectToArray": "$$ROOT" },
                    "as": "el",
                    "cond": {
                        "$eq": [
                            "$$el.v.samekeyA",
                            "value1"
                        ]
                    }
                }
            }
        }   
    } }
])

उपरोक्त पाइपलाइन अंतिम आउटपुट देगी

{
    "key1" : {
        "samekeyA" : "value1",
        "samekeyB" : "value2"
    }
}

स्पष्टीकरण

प्रत्येक व्यक्तिगत ऑपरेटर के परिणाम दिखाने के लिए पाइपलाइन को विघटित किया जा सकता है।

$objectToArray

$objectToArray आपको रूट दस्तावेज़ को डायनेमिक कुंजियों के साथ बदलने में सक्षम बनाता है (सिस्टम वेरिएबल $$रूट ) एक सरणी में जिसमें मूल दस्तावेज़ में प्रत्येक फ़ील्ड/मान जोड़ी के लिए एक तत्व होता है। रिटर्न ऐरे में प्रत्येक तत्व एक दस्तावेज़ है जिसमें दो फ़ील्ड k और v होते हैं। एक $प्रोजेक्ट मंच

db.coll.aggregate([
    { "$project": {
        "keys": { "$objectToArray": "$$ROOT" }
    } }
])

पैदावार

{
    "_id" : 1,
    "keys" : [ 
        {
            "k" : "_id",
            "v" : 1
        }, 
        {
            "k" : "key1",
            "v" : {
                "samekeyA" : "value1",
                "samekeyB" : "value2"
            }
        }, 
        {
            "k" : "key2",
            "v" : {
                "samekeyA" : "value3",
                "samekeyB" : "value4"
            }
        }, 
        {
            "k" : "key3",
            "v" : {
                "samekeyA" : "value5",
                "samekeyB" : "value6"
            }
        }
    ]
}

$filter

$filter ऑपरेटर <द्वारा निर्मित सरणी के लिए फ़िल्टरिंग तंत्र के रूप में कार्य करता है। कोड>$objectToArray ऑपरेटर, निर्दिष्ट शर्त के आधार पर लौटने के लिए सरणी के सबसेट का चयन करके काम करता है जो आपकी क्वेरी बन जाती है।

निम्नलिखित पाइपलाइन पर विचार करें जो { "samekeyA":"value1" } स्थिति से मेल खाने वाली कुंजी/मान जोड़ी की एक सरणी देता है

db.coll.aggregate([
    { "$project": {
        "keys": { 
            "$filter": {
                "input": { "$objectToArray": "$$ROOT" },
                "as": "el",
                "cond": {
                    "$eq": [
                        "$$el.v.samekeyA",
                        "value1"
                    ]
                }
            }  
        }
    } }
])

जो पैदावार

{
    "_id" : 1,
    "keys" : [ 
        {
            "k" : "key1",
            "v" : {
                "samekeyA" : "value1",
                "samekeyB" : "value2"
            }
        }
    ]
}

$arrayToObject

यह ऊपर फ़िल्टर किए गए सरणी को

. से बदल देगा
[ 
    {
        "k" : "key1",
        "v" : {
            "samekeyA" : "value1",
            "samekeyB" : "value2"
        }
    }
]

डायनामिक कुंजी के साथ मूल दस्तावेज़ में

{
    "key1" : {
        "samekeyA" : "value1",
        "samekeyB" : "value2"
    }
}

इसलिए पाइपलाइन चलाना

db.coll.aggregate([
    { "$project": {
        "key": {
            "$arrayToObject": {
                "$filter": {
                    "input": { "$objectToArray": "$$ROOT" },
                    "as": "el",
                    "cond": {
                        "$eq": [
                            "$$el.v.samekeyA",
                            "value1"
                        ]
                    }
                }
            }
        }   
    } }
])

उत्पादन करेगा

{
    "_id" : 1,
    "key" : {
        "key1" : {
            "samekeyA" : "value1",
            "samekeyB" : "value2"
        }
    }
}

$replaceRoot

यह फ़िल्टर किए गए डायनेमिक कुंजी दस्तावेज़ को शीर्ष स्तर पर बढ़ावा देगा और अन्य सभी फ़ील्ड को बदल देगा। ऑपरेशन _id . सहित इनपुट दस्तावेज़ में सभी मौजूदा फ़ील्ड को बदल देता है खेत।

अनिवार्य रूप से यह उपरोक्त दस्तावेज़ को बदल देता है

{
    "_id" : 1,
    "key" : {
        "key1" : {
            "samekeyA" : "value1",
            "samekeyB" : "value2"
        }
    }
}

वांछित अंतिम आउटपुट के लिए

{
    "key1" : {
        "samekeyA" : "value1",
        "samekeyB" : "value2"
    }
}


  1. Redis
  2.   
  3. MongoDB
  4.   
  5. Memcached
  6.   
  7. HBase
  8.   
  9. CouchDB
  1. मैं MongoDB में एम्बेडेड दस्तावेज़ों के लिए अद्वितीय आईडी कैसे बना सकता हूं?

  2. डेटाटाइम के क्षेत्र द्वारा नवीनतम MongoDB रिकॉर्ड प्राप्त करें

  3. मैं मोंगोज़ के साथ ऑब्जेक्ट आईडी कैसे उत्पन्न कर सकता हूं?

  4. कैसे जांचें कि मोंगो का $addToSet डुप्लिकेट था या नहीं

  5. सार्वजनिक बादलों पर MongoDB प्रदर्शन की तुलना करना:AWS, Azure और DigitalOcean