Mongoose: एम्बेडेड दस्तावेज़ के एम्बेडेड दस्तावेज़ पर कॉलिंग पॉप्युलेट

जिस तरह से मैं कर रहा हूं वह वर्तमान में नेस्टेड वस्तुओं को पॉप्युलेट कर रहा है और फिर बच्चों को पॉप्युलेट करने के लिए उनके माध्यम से पुनरावृत्त कर रहा है। मैं कई नेस्टेड स्तरों को आबाद करने के लिए एक समाधान को लागू करने की योजना बना रहा था, लेकिन यह बहुत मुश्किल हो गया।

हाय एनको,

आप यह कैसे कर रहे हैं?

जब आप अपनी पहली आबादी करते हैं, तो आपको नेस्टेड आइटम वापस मिल जाते हैं, लेकिन जब आप उनके बच्चों को आबाद करने के लिए दौड़ते हैं, तो क्या आप आबादी वाले बच्चों को बचाने में सक्षम हैं? जब मैं इसे करने की कोशिश करता हूं तो यह कभी चिपकता नहीं है।

कुछ कोड कमाल का होगा।

धन्यवाद,
पॉल

@eneko कोई बात नहीं, बस जरूरत है .toObject ();)

असल में पॉल, मुझे लगा कि populate() उन प्रश्नों पर काम करता है जो एकाधिक तत्व लौटाते हैं, इसलिए बाल वस्तुओं के माध्यम से पुन: प्रयास करने की कोई आवश्यकता नहीं है। लेकिन हाँ, आप सही हैं, यदि आप चाहते हैं कि गुण चिपके रहें तो आपको .toObject पर कॉल करना होगा।

यहाँ एक उदाहरण है:

// Ideally should be Parent.findOne().populate('children').populate('children.grandchildren').run();

function loadParentWithChildrenAndGrandChildren(parentId) {

  // Load parent without children references (children is array of ObjectId)
  Parent.findOne({ id: parentId }, { children: 0 }, function(err, parent) {
    if (err || !parent) return next(new Error("Parent not found: " + parentId));

    // Load children for this parent, populating grandchildren (no need to load parent reference)
    Children.find({ parent: parent._id }, { parent: 0 })
      .populate('grandchildren', [], { })
      .run(function(err, children) {
        if (err) return next(new Error("Could not load children: " + parentId));

        var result = parent.toObject();
        result.children = children;
        next(null, result);
      });
  });

}

आह, आपके विस्तृत उत्तर के लिए धन्यवाद। आपकी नेवला कॉल मेरी तुलना में अधिक विशिष्ट हैं और मैं आपके दृष्टिकोण से सीख सकता हूं। जैसा कि होता है मेरे विशेष एप्लिकेशन को एक पुनरावर्ती आबादी की आवश्यकता होती है, इसलिए अभी के लिए मैं इसे मैन्युअल रूप से करने में फंस सकता हूं।

मैं अंत में ऐसा कुछ कर रहा हूं।

var viewWithId_forDisplay = function(id, callback) {
if ( !id || typeof id === 'undefined' || id.toString().match(app_utils.emptyReg) ) {
    throw new Error('Bad user ID.');
}

View.findById(id)
.run(function(err, obj) {
    if ( err || !obj || !obj.subviews || !obj.subviews.length ) return callback(err, obj);

    obj = obj.toObject();

    // recursive subview fetch
    async.map( obj.subviews, viewWithId_forDisplay, function(err, results) {
        obj.subviews = results;

        return callback(err, obj);
    } );

})
}

क्या यह अब नवीनतम नेवला रिलीज़ में काम करता है?

तो मुझे लगता है कि यह वह मुद्दा है जिसका मैं अनुभव कर रहा हूं। प्रत्येक टिप्पणी वस्तु में एक एम्बेडेड उपयोगकर्ता वस्तु होती है। टिप्पणियाँ गतिविधि में एक सरणी के रूप में एम्बेड की जाती हैं। गतिविधियों के लिए एक प्रश्न (नीचे के रूप में) प्रत्येक टिप्पणी पर उपयोगकर्ता ऑब्जेक्ट को पॉप्युलेट नहीं करता है।

var get_activities = function (callback) {
  var _this = this
  Activity.find({}, [], {sort:{ _id: -1 }})
  .populate('user')
  .populate('comments')
  .run(function (error, activities) {
    callback(error, activities)
  })
}

var User = new Schema({
    id: { type: String, required: true, lowercase: true, index: { unique: true } }
  , email_address: { type: String, required: true, index: true }
  , name: { type: String, required: true }
  , first_name: { type: String,  required: true } 
  , last_name: { type: String, required: true }
  , user_name : { type: String, required: true, lowercase: true, index: { unique: true } }
  , avatar_url: { type: String, required: true }
  , bio: String
  , following: [{ type: Schema.ObjectId, ref: 'User', index: { unique: true } }]
  , followers: [{ type: Schema.ObjectId, ref: 'User', index: { unique: true } }]
})

var Activity = new Schema({
    id: { type: Number, required: true, index: { unique: true } }
  , user: { type: Schema.ObjectId, ref: 'User', required: true }
  , recipients: [{ type: String, index: { unique: true } }]
  , type: String  
  , body: { type: String, required: true }
  , timestamp: { type: Date, required: true }
  , likes: [{ type: Schema.ObjectId, ref: 'User', index: { unique: true } }]
  , comments: [{ type: Schema.ObjectId, ref: 'Comment' }]
})

var Comment = new Schema({
    id: { type: String, required: true, index: { unique: true } }
  , timestamp: { type: Date, required: true }
  , body: { type: String, required: true }
  , user: { type: Schema.ObjectId, ref: 'User', required: true } 
}) 

क्या इस तरह के मामलों को संभालने के लिए नेस्टेड पथों का समर्थन करने के लिए पॉप्युलेट करने की कोई योजना है?

हाँ हम किसी बिंदु पर चाहेंगे। यह जल्दी से एक प्रदर्शन मुद्दा बन सकता है लेकिन हाँ हमें इसका समर्थन करना चाहिए।

नेस्टेड ऑब्जेक्ट्स के लिए मुझे उन्हें मैन्युअल रूप से लोड करने की आवश्यकता है, जो एक प्रदर्शन समस्या की तरह लगता है और मेरे सर्वर कोड को अव्यवस्थित करता है। तो मैं अपना काम आसान बनाने के लिए +1 हूं ;-)

इस बीच, मैं जारी रखूंगा, और पृष्ठ के अनुभागों को अलग-अलग लोड करने योग्य वस्तुओं में विभाजित करके भी इसे संबोधित करूंगा, जिन्हें प्रत्येक कॉल पर इस तरह के गहरे नेस्टेड डेटा की आवश्यकता नहीं होती है।

मैं सब कुछ इस तरह के लिए होगा;

Parent.findById(1).populate('child').run(function (err, parent) {
  parent.child.populate('grandchild', function (err) {
    console.log(parent.child.grandchild)
  })
})

इस तरह के दस्तावेज़ पर पॉप्युलेट उपलब्ध होना वास्तव में बहुत आसान होगा। जहाँ तक आपको आवश्यकता हो, आप गोता लगाते रह सकते हैं।

@Qard तुमने मेरा दिमाग पढ़ा।

@Qard इस तरह नेवले-रिश्ते काम करते हैं। मैंने पहले कुछ समय के लिए उस मॉड्यूल का इस्तेमाल किया, लेकिन चीजों को मैन्युअल रूप से करना समाप्त कर दिया। हो सकता है कि मोंगोज़ को इसे कोर में एकीकृत करना चाहिए, या इसके कम से कम कुछ हिस्सों को कॉल करना जैसे सरणी पर पॉप्युलेट करना चाहिए।

क्या https://github.com/LearnBoost/mongoose/issues/601#issuecomment -3258317 जैसा कुछ अभी तक लागू किया गया है?

मैं वही बात सोच रहा हूँ। मैं यह पता लगाने की कोशिश कर रहा हूं कि एम्बेडेड डॉक्टर बाल संदर्भों को कैसे पॉप्युलेट किया जाए। @dbounds मेरे पास एक समान मॉडल हैं। क्या आपने इस समस्या का समाधान किया है: https://github.com/LearnBoost/mongoose/issues/601#issuecomment -3088564। मुझे नेवले-रिश्ते नहीं मिल रहे हैं

इस थ्रेड की जानकारी .populate() की वर्तमान स्थिति को समझने में बहुत मददगार रही है, पोते-पोतियों की नेस्टेड आबादी से संबंधित वर्तमान सीमा और मैन्युअल लुकअप के साथ संयोजन में .toObject() इसे कैसे हल करने का एक विकल्प हो सकता है।

मैं सोच रहा हूं कि क्या कोई ऐसी तकनीक है जिसका हम उपयोग कर सकते हैं जिसके लिए .toObject() की आवश्यकता नहीं है। हम अपने मॉडल और पोते-पोतियों को आबाद करने के बाद b\c से पूछते हैं कि हम अभी भी एक दस्तावेज़ और उचित प्रकार चाहते हैं ताकि हम parent.childarray.id(x) जैसे कार्यों का उपयोग कर सकें या मानों को संशोधित कर सकें और .save() को कॉल कर सकें।

यहां जो भी मदद करेंगे उसकी बहुत सराहना की जाएगी।

नोट: हमने parent.set ('child.grandchild', value) का उपयोग करने का प्रयास किया है, हालांकि ऐसा लगता है कि दस्तावेज़ की अखंडता के साथ कुछ समस्याएं उत्पन्न होती हैं और हम अब उस पथ से मान पढ़ने में सक्षम नहीं हैं (त्रुटि अमान्य ऑब्जेक्ट आईडी है जब पैरेंट.चाइल्ड या पेरेंट.चाइल्ड.ग्रैंडचाइल्ड पढ़ने की कोशिश की जा रही हो)।

संबंधित: http://stackoverflow.com/questions/11137239/querying-nested-embedded-documents-with-mongoose

@aheckmann इस पर अभी तक कोई विचार?

बहुत व्यस्तता थी। मैं इसे 3.0 फाइनल में चाहता हूं

@aheckmann बहुत बढ़िया इंतजार नहीं कर सकता। यह वास्तविक अनुप्रयोगों में वास्तव में उपयोगी होगा। लेकिन अब तक आपने जो कुछ भी हासिल किया है, उसके लिए मैं आपको महान कार्य के लिए बधाई देना चाहता हूं।

बहुत बढ़िया! इस सुविधा के उपलब्ध होते ही मैं इसका उपयोग करूंगा।

हे दोस्तों, मैंने नेवला के चारों ओर अपनी खुद की परत लिखी है जो उप-जनसंख्या का समर्थन करती है। यह वास्तुशिल्प रूप से आदर्श नहीं है क्योंकि यह एक आवरण के चारों ओर एक आवरण है, लेकिन यह उस तरह से उप-आबादी का समर्थन करता है जिस तरह से हम इसे काम करना चाहते हैं। क्या किसी को इसे देखने में दिलचस्पी है अगर मैं इसे साफ कर दूं और इसे छोड़ दूं?

निश्चित रूप से दिलचस्पी! मुझे यकीन नहीं है कि मैं पैचिंग करने के लिए सही व्यक्ति हूं, लेकिन अभी इस मुद्दे को कैसे हल किया जाए, इस पर किसी भी विचार का बहुत स्वागत है!

अभी यह एक हैक है, हालांकि मेरे दृष्टिकोण से एक सुखद हैक :) उम्मीद है कि इसका उपयोग नेवला को पैच करने के लिए किया जा सकता है लेकिन यह इस समय एक बंदर-पैच है। मैं कुछ और परीक्षण लिखूंगा, अपने कोड का दस्तावेजीकरण करूंगा, और अगले सप्ताह के भीतर यहां वापस आऊंगा।

क्या इसे संस्करण 3.0 में जोड़ा जाएगा?

@hackfrag हाँ

क्या यह 3.0 में है या इसे अभी भी जोड़ा जा रहा है। अगर ऐसा है तो हमारे पास एक उदाहरण हो सकता है :)

यह 3.0 में नहीं है। इसे आगामी लघु रिलीज में जोड़ा जाएगा।

मुझे इस कार्यक्षमता को हैक करने का प्रयास करने में अविश्वसनीय रूप से कठिन समय हो रहा है। क्या आपके पास कोई अनुमान है कि यह रिलीज़ कब उपलब्ध हो सकती है? यदि निकट भविष्य में सच्चा समर्थन मिलता है तो मैं अपने बदसूरत कोड को हटा दूंगा और अपने आवेदन के अन्य क्षेत्रों पर काम करूंगा :)। और क्या मैं जोड़ सकता हूं, भयानक पुस्तकालय के लिए धन्यवाद।

Stowns, मेरी हैक अच्छी तरह से काम कर रही है और अब मैं इसे जारी करने के बारे में काफी अच्छा महसूस कर रहा हूं। मैं 24 घंटे के भीतर आपसे संपर्क करूंगा - पहले Mongoose 3 के खिलाफ परीक्षण करने की आवश्यकता है

— जोशुआ ग्रॉस
ईसाई / वेब विकास सलाहकार / कंप्यूटर विज्ञान के बीए उम्मीदवार, यूडब्ल्यू-मैडिसन 2013
414-377-1041 / http://www.joshisgross.com

13 अगस्त 2012 को शाम 6:56 बजे, स्टौंस नोटिफिकेशन @github.com ने लिखा:

मुझे इस कार्यक्षमता को हैक करने का प्रयास करने में अविश्वसनीय रूप से कठिन समय हो रहा है। क्या आपके पास कोई अनुमान है कि यह रिलीज़ कब उपलब्ध हो सकती है? यदि निकट भविष्य में सच्चा समर्थन मिलता है तो मैं अपने बदसूरत कोड को हटा दूंगा और अपने आवेदन के अन्य क्षेत्रों पर काम करूंगा :)

-
इस ईमेल का सीधे उत्तर दें या इसे GitHub पर देखें।

@ जोशुआ ग्रॉस अरे क्या आप अपनी हैक को एक सार में डाल सकते हैं? मेरा कोड इस सुविधा के बिना बहुत गन्दा और बदसूरत होता जा रहा है ...

अरे @madhums , @stowns , @aheckmann , @farhanpatel , @hackfrag , @jsalonen , आदि। मेरा हैक (केवल Mongoose 2.7 पर परीक्षण किया गया) यहां है: https://github.com/JoshuaGross/mongoose-subpopulate

आशा है कि यह मददगार है।

वाह यहोशू! बहुत - बहुत धन्यवाद!

मैं निश्चित रूप से इसे तुरंत देख लूंगा!

धन्यवाद @JoshuaGross , आज बाद में इसकी जाँच करेंगे

ऐसा तब होना था जब किसी भी दस्तावेज़ में "पॉप्युलेट" करने के लिए फ़ील्ड नहीं है जो खोज करने का अनुरोध कर रहा है? त्रुटियां होंगी? तकनीकी रूप से कोई त्रुटि नहीं होगी, लेकिन क्या यह दस्तावेज़ दिखाया जाएगा?

क्या नेस्टेड पॉप्युलेट () कॉल अभी तक काम करती हैं? ऐसा लगता है कि कुछ गतिविधि हुई है, लेकिन मैं यह निर्धारित करने में असमर्थ था कि इसे कैसे किया जाए।

मेरे पास है:

List.findById(req.params.id).populate('items').populate('items.user').exec(fn);

उपयोगकर्ता एक गहरा घोंसला है ... क्या इसे पॉप्युलेट करना संभव है?

@chovy चेक आउट https://github.com/JoshuaGross/mongoose-subpopulate

@aheckmann क्या आप इस पर टिप्पणी कर सकते हैं? मैं उप-जनसंख्या करने के लिए काफी समय से उत्पादन में नेवला-उप-जनसंख्या का उपयोग कर रहा हूं।

नेवला-उप-जनसंख्या एक्सप्रेस 3 के साथ काम नहीं करता।

मेरी एक शाखा शुरू हो गई है लेकिन मैं काफी व्यस्त हूं। वो रास्ते में है।

बुध, अक्टूबर 3, 2012 अपराह्न 11:37 बजे, एंथनी एटिंगर
सूचनाएं@github.comलिखा है :

नेवला-उप-जनसंख्या एक्सप्रेस 3 के साथ काम नहीं करता।

-
इस ईमेल का सीधे उत्तर दें या इसे Gi tHubhttps: //github.com/LearnBoost/mongoose/issues/601#issuecomment -9131991 पर देखें।

हारून
@aaronheckmann https://twitter.com/#!/aaronheckmann

@chovy क्या आपका मतलब नेवला 3 है? मैं एक्सप्रेस 3 के साथ नेवला-उप-जनसंख्या का उपयोग करता हूं।

हाँ, नेवला 3 मेरा मतलब था।

@aheckmann - आपकी शाखा देखने के लिए उत्सुक!

मैं समझ नहीं पाया कि नेवला-उप-जनसंख्या का उपयोग कैसे करें

इस सुविधा के लिए +1

इसके लिए +1

सरणी के सरणी बच्चे को पॉप्युलेट करने का कोई तरीका है?

var notifications = new Schema({
    _id             : { type : ObjectId }
    , from          : { type : ObjectId, ref: 'user' }
    , status                : { type : Number, default : 1 }
    , created_at            : { type : Date }
    , updated_at            : { type : Date }
});

var applications = new Schema({
    _id                     : { type : ObjectId, required : true, ref : 'application' }
    , notifications                 : [notifications]
});

var schema = new Schema({
    name                        : { type : String, required : true }
    , email                     : { type : String }
    , applications                      : [applications]
    , created_at                        : { type : Date }
    , updated_at                        : { type : Date }
});

var User = module.exports = mongoose.model('user', schema);

अधिसूचना प्रेषक का नाम पाने के लिए मैं यहां क्या हासिल करना चाहता हूं

// works like a charm
User.findOne({_id:'me'}).populate('applications');

// doesn't work
User.findOne({_id:'me'}).populate('applications.notifications.from');

या यदि कोई अन्य तरीका है जो सभी उपयोगकर्ता नाम मैन्युअल रूप से प्राप्त करने के लिए कोई अन्य क्वेरी करता है?

आपको "से" एक सरणी बनाने की आवश्यकता होगी जैसे आप सूचनाओं के साथ कर रहे हैं। करने के लिए सबसे अच्छी बात यह है कि उपयोगकर्ता को आपके कॉलबैक में प्रत्येक अधिसूचना के लिए लाया जाता है।

हां, मैं सिर्फ आबादी को मैन्युअल रूप से कर रहा हूं, अगर पॉप्युलेट गहरे संदर्भों के साथ भी काम करता है तो बैल अच्छा होगा ...

+1, उम्मीद कर रहा था कि मैं नीचे पहुंच जाऊंगा और देखूंगा कि यह अंदर था और मैं इसे सही नहीं कर रहा था। :(

+1, इस सुविधा के लिए कोई समयरेखा अनुमान? यह पागलपन की हद तक मददगार होगा।

@winduptoy 3.6 की तरह दिख रहा है

+1 यहाँ भी।

इससे भी महत्वपूर्ण बात यह है कि हमें कम से कम बच्चों को पहले मूल वस्तु पर toObject () को कॉल किए बिना खुद को पॉप्युलेट करने में सक्षम होना चाहिए। मैं सेट कॉल के बाद फ़ील्ड प्रकारों को सुसंगत रखने की इच्छा को समझ सकता हूं, लेकिन नेवला पहले से ही इस नियम को पॉप्युलेट फ़ंक्शन के साथ शुरू करने के लिए तोड़ देता है। हमें नेवले को केवल मोंगो आईडी में बदले बिना एक संदर्भित फ़ील्ड को पूरी वस्तु पर सेट करने में सक्षम होना चाहिए।

इस स्नफू के अलावा, नेवले से प्यार है।

मैं इस सुविधा के लिए बहुत उत्सुक हूं।

+1 मुझे भी इस सुविधा की आवश्यकता है ...

इस भविष्य के लिए +1

+1 - इसके लिए तत्पर हैं

+1 यह बहुत अच्छा होगा

+1 यह सॉफ़्टवेयर समस्याओं के लिए आया था, लेकिन यदि आप एक और प्रतीक डालते हैं तो मदद मिलेगी, उदाहरण के लिए

User.findOne({_id:'me'}).populate('applications$notifications.from');
// Arrays $
// Simple document point "."

तो समस्याओं से बचें नहीं... नहीं?

+2

+1 यह मददगार होगा।

+1 ऐसा करना आपके लिए बहुत अच्छा होगा।

कृपया उस सुविधा को 2013 में जारी करें

+1 मुझे अभी इसकी आवश्यकता है, यह बहुत उपयोगी होगा।

आप में से जिन लोगों को अभी इसकी आवश्यकता है, उनके लिए आप नेवला-उप-जनसंख्या की जाँच करना चाह सकते हैं। मैं इसे कई महीनों से उपयोग कर रहा हूं: https://github.com/JoshuaGross/mongoose-subpopulate (मैं अनुरक्षक हूं)

यहाँ 3.6 में आबाद करने की योजना है: https://github.com/LearnBoost/mongoose/pull/1292

+1 हमें इसकी आवश्यकता है। उम्मीद है कि जल्द ही जारी किया जाएगा, (क्योंकि यह मुद्दा साल पहले ही शुरू हो चुका है)

मुझे लगता है कि लोकप्रिय वोट से, इस प्रस्ताव को जीत लिया!

किया हुआ। https://github.com/LearnBoost/mongoose/wiki/3.6-pre-release-notes

@aheckmann बहुत बहुत धन्यवाद !!

इसके अलावा lean() से भी प्यार करें, इसलिए यह अब तक वास्तव में शानदार लगता है!

3.6 के लिए उत्साहित, यह एक अच्छा समाधान है, धन्यवाद!

धन्यवाद श्रीमान!

5 मार्च 2013 को शाम 5:26 बजे, एंडी बर्क नोटिफिकेशन @github.com ने लिखा:

3.6 के लिए उत्साहित, यह एक अच्छा समाधान है, धन्यवाद!

-
इस ईमेल का सीधे उत्तर दें या इसे GitHub पर देखें।

@aheckmann ग्रेट, धन्यवाद!

धन्यवाद!!! अच्छा काम!!!

वह तो कमाल है! मुझे विश्वास है कि यह मेरे मामले में मदद कर सकता है। मुझे इस परिदृश्य में कैसे करना चाहिए:

var UserSchema, WineRating, WineSchema, mongoose;

UserSchema = new mongoose.Schema({
  wine_ratings: {
    type: [
      {
        type: mongoose.Schema.Types.ObjectId,
        ref: 'WineRating'
      }
    ]
  }
});
mongoose.model("User", UserSchema);

WineRating = new mongoose.Schema({
  wine: {
    type: mongoose.Schema.Types.ObjectId,
    ref: 'Wine'
  }
});
mongoose.model("WineRating", WineRating, 'wine_ratings');


WineSchema = new mongoose.Schema({
  name: String
});
mongoose.model("Wine", WineSchema);

mongoose.model("User").findById(user._id).populate('wine_ratings.wine').exec(function(err, user) {});
/*
gets exception: 
TypeError: Cannot call method 'path' of undefined
    at search (/Users/flockonus/workspace/az/api/node_modules/mongoose/lib/model.js:1830:28)
    at search (/Users/flockonus/workspace/az/api/node_modules/mongoose/lib/model.js:1849:22)
    at Function._getSchema (/Users/flockonus/workspace/az/api/node_modules/mongoose/lib/model.js:1856:5)
    at populate (/Users/flockonus/workspace/az/api/node_modules/mongoose/lib/model.js:1594:22)
    at Function.Model.populate (/Users/flockonus/workspace/az/api/node_modules/mongoose/lib/model.js:1573:5)
    at Query.findOne (/Users/flockonus/workspace/az/api/node_modules/mongoose/lib/query.js:1633:11)
    at exports.tick (/Users/flockonus/workspace/az/api/node_modules/mongoose/lib/utils.js:393:16)
*/

क्या वहाँ कुछ गड़बड़ है? मैं "3.6.0rc0" पर हूं

मेरे पास एक ही समस्या है: https://github.com/LearnBoost/mongoose/issues/1377

@ फ्लॉकोनस @ वोवन 22 मैं उसी मुद्दे पर भागा। इस तरह मैंने इसे हल किया।

मैं अपनी परियोजना में post.populate("comments comments._creator") काम करने की कोशिश कर रहा था, और निम्नलिखित बदलावों के साथ थोड़ी सफलता मिली।

ऐसा लगता है कि यह गहन प्रश्नों के लिए काम नहीं करता है, और पहला परिवर्तन कुछ मौजूदा परीक्षणों को तोड़ देता है , लेकिन मुझे आशा है कि यह इस पर काम करने वाले किसी भी व्यक्ति के लिए रुचिकर हो सकता है।

https://gist.github.com/joeytwiddle/6129653

चूंकि मेरा पैच थोड़े बेकार है, मैंने इसके बजाय एक टेस्ट केस लिखकर योगदान करने की कोशिश की है! https://github.com/LearnBoost/mongoose/pull/1603

joeytwiddle, मुझे ठीक वही समस्या हो रही है और मुझे आशा है कि आप इसे ठीक कर लेंगे - मैं पुनरावर्ती रूप से पॉप्युलेट करने की कोशिश कर रहा हूं लेकिन मुझे पथ त्रुटि भी नहीं मिल रही है। मुझे नहीं पता कि यह डिज़ाइन द्वारा है ...

हाँ कुख्यात 601। यह डिजाइन द्वारा है, कम से कम फिलहाल के लिए। नवीनतम Mongoose रिलीज़ गहरी आबादी का समर्थन करती है, लेकिन _only एक स्कीमा के भीतर_।

हमारी परियोजना में हमें अक्सर विभिन्न मॉडलों में गहरी आबादी करने की आवश्यकता होती है, इसलिए हमने एक सहायक कार्य लिखा है:

https://gist.github.com/joeytwiddle/6129676

यह आपको एक दस्तावेज़ के वंशजों को अपनी पसंद की किसी भी गहराई तक आबाद करने की अनुमति देता है! दस्तावेज़ प्राप्त करने के बाद भी इसे एक अतिरिक्त कॉलबैक की आवश्यकता होती है, लेकिन केवल एक। उदाहरण के लिए:

deepPopulate(blogPost, "comments comments._creator comments._creator.blogposts", {sort:{title:-1}}, callback);

मुझे आशा है कि मॉडल प्राप्त करने के लिए doc.constructor का उपयोग भविष्य में समस्याग्रस्त साबित नहीं होगा!

_(सनराइड और जर्मन सरकार को धन्यवाद!)_

@joeytwiddle - बहुत बहुत धन्यवाद! इसने एक जादू की तरह काम किया। अब मैं इसे एन-डीप पॉप्युलेट करने का एक तरीका निकालने का प्रयास करूंगा।

इस पर कोई अपडेट?

@aheckmann मैं इस पर आपके सिद्धांत को समझता हूं, लेकिन मैं असहमत हूं कि यह एक विरोधी पैटर्न है।

कभी-कभी आपको महंगे संचालन करने की आवश्यकता होती है, जटिल प्रणालियों में यह अपरिहार्य है और आपको अलग-अलग दस्तावेजों को एक साथ एकत्र करने की आवश्यकता है। उदाहरण के लिए, आप एक महंगा ऑपरेशन करना चाह सकते हैं जब कोई दस्तावेज़ बहुत कम बदलता है और प्रदर्शन के लिए परिणामों को कैश करता है।

आप क्यों मानते हैं कि जनसंख्या का एक स्तर 'ठीक' है, लेकिन इससे अधिक होना एक प्रतिमान विरोधी का संकेत है?

मुझे पता है कि यह एक पुराना धागा है, लेकिन मैंने अभी एक प्लगइन बनाया है जो गहराई के किसी भी स्तर पर मॉडल को पॉप्युलेट करना बहुत आसान बनाता है। अगर किसी की दिलचस्पी है तो मैं यहां पोस्ट कर रहा हूं: https://github.com/buunguyen/mongoose-deep-populate।

उपयोग बहुत सीधा है, उदाहरण के लिए:

post.deepPopulate('votes.user, comments.user.followers, ...', cb);
Post.deepPopulate(posts, 'votes.user, comments.user.followers', cb);

अधिक जानकारी के लिए कृपया प्लगइन रेपो देखें।

@buunguyen अच्छा काम!

मेरे लिए काम नहीं कर रहा।

मॉडल/मिशनपार्टीसिपेशन.जेएस

var deepPopulate = require('mongoose-deep-populate');
var mongoose = require('mongoose');
var Types = mongoose.Schema.Types;

var missionParticipationSchema = new mongoose.Schema({
        user: {
            type: String,
            default: ''
        },
        mission: {
            type: Types.ObjectId,
            ref: 'Mission'
        },
        images: [{
            type: Types.ObjectId,
            ref: 'Image'
        }]
    }, {
        toJSON: {
            getters: true,
            virtuals: true
        },
        toObject: {
            getters: true,
            virtuals: true
        }
    });

    missionParticipationSchema.plugin(deepPopulate, {
        whitelist: [
            'images',
            'mission',
            'mission.images.poster',
            'mission.images.banner'
        ]
    });

var MissionParticipation = mongoose.model('MissionParticipation', missionParticipationSchema);

module.exports = MissionParticipation;

सेवाएं/मिशनभागीदारीService.js

MissionParticipation.find({user: userID}).deepPopulate('mission.images.poster mission.images.banner').exec(function (err, missionParticipationsDocs) {
    // do the magic.
});

और मुझे यह त्रुटि कंसोल पर मिलती है

TypeError: Object #<Query> has no method 'deepPopulate'

@joaom182
मैंने अभी तक डीपपॉप्युलेट का उपयोग नहीं किया है, लेकिन http://npm.taobao.org/package/mongoose-deep-populate पर दस्तावेज़ों को रिकॉर्ड करना मुझे लगता है कि सही कॉल होना चाहिए:

MissionParticipation.find({user: userID}, function (err, participations) {
  MissionParticipation.deepPopulate(participations, 'mission.images.poster mission.images.banner', function(err) {
    if (err) {
      //handle it
      return void 0;
    }
    //do your magic stuff. with participations, which are populated in place in the examples 
  })
})

सादर

मुझे एक और रास्ता मिल गया, लेकिन मैं प्रदर्शन के बारे में चिंतित हूं, मैं तुलना करने की कोशिश करता हूं।

दूसरा तरीका async मॉड्यूल का उपयोग करता है

MissionParticipation.find({
   user: userID
}).populate('mission').exec(function (err, missionParticipationsDocs) {
   if (err)
      return; // handle error

   async.forEach(missionParticipationsDocs, function (mp, callback) {
      mp.mission.populate('images.poster', 'images.banner', 'prize', function (err, result) {
         callback();
      });
   }, function (err) {
      // forEach async completed
      if(err)
         return; // handle error
      resolve(missionParticipationsDocs);
   });
});

@ joaom182 आप थोड़े तेज़ हैं :)। हालांकि मैंने deepPopulate से Query लाने के लिए कोड जोड़ा, लेकिन मैंने NPM पर एक नया संस्करण डालने में देरी की ताकि मैं थोड़ा और परीक्षण कर सकूं।

मैंने अभी नए संस्करण (0.0.7) को आगे बढ़ाया है। तो निर्भरता को अपडेट करने के बाद आपके द्वारा उपयोग किया जाने वाला यह सिंटैक्स काम करना चाहिए:

MissionParticipation
  .find({user: userID})
  .deepPopulate('mission.images.poster mission.images.banner')
  .exec(cb);

@buunguyen बहुत बढ़िया!

क्या आप भविष्य के मुद्दों को नेवला-डीप-पॉप्युलेट रेपो में खोल सकते हैं? सबके जीवन को थोड़ा आसान बना देता है :)

@buunguyen बहुत बढ़िया! सबसे अच्छी बात जो मेरे प्रोजेक्ट के साथ हुई और आपने मेरा दिन बना दिया! धन्यवाद!