किसी क्वेरी के समान ही सरणी प्रविष्टियों वाले दस्तावेज़ कैसे खोजें

यहां कई "बहुत उपयोगी मामले" हैं जहां वास्तव में सरणी सामग्री पर "अद्वितीय हैश" बनाने की कोशिश करना वास्तव में असंख्य समस्याओं का "रास्ते में आना" है जिसे आसानी से संबोधित किया जा सकता है।

"मैं" के लिए सामान्य ढूँढना

यदि आप उदाहरण के लिए प्रदान किए गए नमूने से "उपयोगकर्ता 1" लेते हैं, और विचार करें कि आपके पास वह डेटा पहले से ही लोड है और वर्तमान उपयोगकर्ता ऑब्जेक्ट से मेल खाने वाले "आइटम आईडी" द्वारा "मेरे साथ आम लोगों" को ढूंढना चाहते हैं, तो वहां दो सरल क्वेरी दृष्टिकोण हैं:

"बिल्कुल वही" ढूंढें: वह जगह है जहां आप उन उपयोगकर्ताओं को देखने के लिए अन्य उपयोगकर्ता डेटा का निरीक्षण करना चाहते हैं जिनके समान "सटीक" हित हैं। यह का सरल और "अनियंत्रित" उपयोग है। $सभी क्वेरी ऑपरेटर:
```
db.collection.find({ 
    "itemsIds": { "$all": [399957190, 366369952] },
    "userId": { "$ne": 1 }
})
```
जो "उपयोगकर्ता 3" वापस करने जा रहा है क्योंकि वे "दोनों" सामान्य "आइटम आईडी" प्रविष्टियों वाले हैं। यहां आदेश महत्वपूर्ण नहीं है क्योंकि यह हमेशा किसी भी क्रम में एक मैच होता है, जब तक कि वे दोनों वहां हों। यह $और . का दूसरा रूप है क्वेरी तर्क के रूप में।
मेरे समान "समान" ढूंढें: जो मूल रूप से पूछ रहा है "क्या आपके पास ऐसा कुछ है जो समान है?" . उसके लिए आप $in क्वेरी ऑपरेटर। यह मेल खाएगा यदि निर्दिष्ट शर्तों में से "या तो" पूरी होती है:
db.collection.find({ "itemsIds": { "$in": [399957190, 366369952] }, "userId": { "$ne": 1 } }) इस मामले में "दोनों" "उपयोगकर्ता 2" और "उपयोगकर्ता 3" मेल खाने जा रहे हैं, क्योंकि वे निर्दिष्ट शर्तों में से "कम से कम" साझा करते हैं और इसका मतलब है कि स्रोत डेटा के साथ "कुछ समान" है क्वेरी। यह वास्तव में $या . का दूसरा रूप है क्वेरी ऑपरेटर, और पहले की तरह इसे लागू करने की शर्तों को देखते हुए इस तरह लिखना बहुत सरल और संक्षिप्त है।

 सामान्य "चीजें" ढूँढना
 
 ऐसे मामले भी हैं जहां से शुरू करने के लिए आप आधार "उपयोगकर्ता" के बिना "सामान्य रूप से" चीजें ढूंढना चाहेंगे। तो आप कैसे बताते हैं कि "उपयोगकर्ता 1" और "उपयोगकर्ता 2" समान "आइटम आईडी" साझा करते हैं, या वास्तव में विभिन्न उपयोगकर्ता एक ही "आइटम आईडी" मान को अलग-अलग साझा कर सकते हैं, लेकिन वे कौन हैं?
   
 सटीक मिलान प्राप्त करें: निश्चित रूप से आप "आइटम आईडी" मान और  को देखते हैं। $समूह  
 उन्हें एक साथ। आम तौर पर यहां "आदेश महत्वपूर्ण है", इसलिए बेहतर है कि आपने उन्हें "पूर्व-आदेशित" किया है और लगातार इसे हमेशा सरल बनाने के लिए:
 db.collection.aggregate([
    { "$group": {
        "_id": "$itemsIds",
        "common": { "$push": "$userId" }
    }}
])
 
 और वास्तव में यही सब है, जब तक कि आदेश पहले से ही है। यदि नहीं, तो आप "ऑर्डरिंग" करने के लिए थोड़ा लंबा घुमावदार फॉर्म कर सकते हैं, लेकिन "हैश" उत्पन्न करने के बारे में भी यही कहा जा सकता है:
 db.collection.aggregate([
    { "$unwind": "$itemsIds" },
    { "$sort": { "_id": 1, "itemsIds": 1 } },
    { "$group": {
        "_id": "$_id",
        "userId": { "$first": "$userId" },
        "itemsIds": { "$push": "$itemsIds" }
    }},
    { "$group": {
        "_id": "$itemsIds",
        "common": { "$push": "$userId" }
    }}
])
 
 "सुपर" प्रदर्शन करने वाला नहीं है, लेकिन यह इस बात को इंगित करता है कि आप हमेशा सरणी प्रविष्टियों को जोड़ने पर आदेश क्यों देते हैं। जो एक बहुत ही सरल प्रक्रिया है।
 
  
 सामान्य "उपयोगकर्ता" से "आइटम": $अनविंड . के अंतर्गत "ब्रेकिंग डाउन" एरे के साथ उपरोक्त पर सारगर्भित एक और सरल प्रक्रिया कौन सी है? , और फिर मूल रूप से वापस समूहबद्ध करना:
 db.collection.aggregate([
    { "$unwind": "$itemsIds" },
    { "$group": {
        "_id": "$itemsIds",
        "users": { "$addToSet": "$userId" }
    }}
])
 
 और फिर, $ का एक साधारण समूहीकरण एग्रीगेटर AddToSet  
 काम करता है और प्रत्येक "आइटम आईडी" मान के लिए "विशिष्ट उपयोगकर्ता आईडी" मान एकत्र करता है।
 
 
 
 ये सभी बुनियादी समाधान हैं, और मैं "सेट चौराहे" के साथ आगे बढ़ सकता हूं और क्या नहीं, लेकिन यह "प्राइमर" है।
 
 "हैश" की गणना करने की कोशिश न करें, वैसे भी प्रविष्टियों से मेल खाने के लिए मोंगोडीबी के पास एक अच्छा "शस्त्रागार" है। इसका उपयोग करें और "दुरुपयोग" भी करें, जब तक कि यह टूट न जाए। फिर अधिक प्रयास करें।