MongoDB एक अनुक्रमित कॉलम पर गिनती (अलग x) का चयन करें - बड़े डेटा सेट के लिए अद्वितीय परिणाम गिनें

Question 1

मैं कई लेखों और उदाहरणों से गुज़रा हूँ, और अभी तक MongoDB में इस SQL क्वेरी को करने के लिए एक कुशल तरीका खोजना है (जहाँ लाखों लोग हैं ~~पंक्तियों~~ दस्तावेज)

पहली कोशिश

(इस लगभग डुप्लिकेट प्रश्न से - एसक्यूएल की चयन सूची के मानगो बराबर? )

db.myCollection.distinct("myIndexedNonUniqueField").length

जाहिर है मुझे यह त्रुटि मिली क्योंकि मेरा डेटासेट बहुत बड़ा है

Thu Aug 02 12:55:24 uncaught exception: distinct failed: {
        "errmsg" : "exception: distinct too big, 16mb cap",
        "code" : 10044,
        "ok" : 0
}

दूसरा प्रयास

मैंने एक समूह बनाने की कोशिश की

db.myCollection.group({key: {myIndexedNonUniqueField: 1},
                initial: {count: 0}, 
                 reduce: function (obj, prev) { prev.count++;} } );

लेकिन मुझे इसके बजाय यह त्रुटि संदेश मिला:

exception: group() can't handle more than 20000 unique keys

तीसरा प्रयास

मैंने अभी तक कोशिश नहीं की है लेकिन इसमें कई सुझाव हैं mapReduce

जैसे

यह एक मोंगोडब में अलग और समूह कैसे करना है?(स्वीकृत नहीं, उत्तर लेखक / ओपी ने इसका परीक्षण नहीं किया)
कार्यक्षमता द्वारा यह एक MongoDB समूह (दूसरे प्रयास के समान लगता है)
यह एक http://blog.emmettshear.com/post/2010/02/12/Counting-Uniques-With-pong/2010DB
यह एक https://groups.google.com/forum/?fromgroups# .topic/mongodb-user/trDn3jJjqtE
यह एक http://cookbook.mongodb.org/patterns/unique_items_map_reduce/

भी

ऐसा लगता है कि GitHub पर एक पुल अनुरोध है, जिसका .distinctउल्लेख करने के लिए विधि को ठीक करना चाहिए केवल एक गिनती वापस करनी चाहिए, लेकिन यह अभी भी खुला है: https://github.com/mongodb/mongo/pull/34

लेकिन इस बिंदु पर मैंने सोचा कि यह यहाँ पूछने लायक है, इस विषय पर नवीनतम क्या है? क्या मुझे अलग-अलग काउंट के लिए SQL या किसी अन्य NoSQL DB में जाना चाहिए? या एक कुशल तरीका है?

अपडेट करें:

MongoDB आधिकारिक डॉक्स पर यह टिप्पणी उत्साहजनक नहीं है, क्या यह सटीक है?

http://www.mongodb.org/display/DOCS/Aggregation#comment-430445808

Update2:

लगता है कि नई एग्रीगेशन फ्रेमवर्क उपरोक्त टिप्पणी का उत्तर देती है ... (मोंगोडो 2.1 / 2.2 और ऊपर, विकास पूर्वावलोकन उपलब्ध है, उत्पादन के लिए नहीं)

http://docs.mongodb.org/manual/applications/aggregation/

Question 2

1) ऐसा करने का सबसे आसान तरीका एकत्रीकरण ढांचे के माध्यम से है। यह दो "$ समूह" कमांड लेता है: अलग-अलग मूल्यों द्वारा पहला एक समूह, दूसरा वाला सभी अलग-अलग मूल्यों को गिनता है

pipeline = [ 
    { $group: { _id: "$myIndexedNonUniqueField"}  },
    { $group: { _id: 1, count: { $sum: 1 } } }
];

//
// Run the aggregation command
//
R = db.runCommand( 
    {
    "aggregate": "myCollection" , 
    "pipeline": pipeline
    }
);
printjson(R);

2) यदि आप मानचित्र के साथ ऐसा करना चाहते हैं / कम कर सकते हैं। यह भी दो-चरण की प्रक्रिया है: पहले चरण में हम कुंजी के लिए हर अलग मूल्य की एक सूची के साथ एक नया संग्रह बनाते हैं। दूसरे में हम नए संग्रह पर एक गिनती () करते हैं।

var SOURCE = db.myCollection;
var DEST = db.distinct
DEST.drop();


map = function() {
  emit( this.myIndexedNonUniqueField , {count: 1});
}

reduce = function(key, values) {
  var count = 0;

  values.forEach(function(v) {
    count += v['count'];        // count each distinct value for lagniappe
  });

  return {count: count};
};

//
// run map/reduce
//
res = SOURCE.mapReduce( map, reduce, 
    { out: 'distinct', 
     verbose: true
    }
    );

print( "distinct count= " + res.counts.output );
print( "distinct count=", DEST.count() );

ध्यान दें कि आप नक्शे के परिणाम को वापस नहीं कर सकते हैं / इनलाइन को कम कर सकते हैं, क्योंकि यह संभावित रूप से 16MB दस्तावेज़ आकार सीमा को पार कर जाएगा। आप एक संग्रह में गणना को सहेज सकते हैं और फिर संग्रह के आकार () को गिन सकते हैं, या आप mapReduce के रिटर्न मान से परिणाम की संख्या प्राप्त कर सकते हैं ()।

Question 3

db.myCollection.aggregate( 
   {$group : {_id : "$myIndexedNonUniqueField"} }, 
   {$group: {_id:1, count: {$sum : 1 }}});

परिणाम के लिए सीधे:

db.myCollection.aggregate( 
   {$group : {_id : "$myIndexedNonUniqueField"} }, 
   {$group: {_id:1, count: {$sum : 1 }}})
   .result[0].count;

Question 4

निम्नलिखित समाधान ने मेरे लिए काम किया

db.test.distinct ( 'उपयोगकर्ता'); ["एलेक्स", "इंग्लैंड", "फ्रांस", "ऑस्ट्रेलिया"]

db.countries.distinct ('देश')। लंबाई 4