मैं couchdb दृश्य में एक और दृश्य कैसे कॉल कर सकता हूं?

Question

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

उदाहरण: (!):

{ 
    "_id": "1", 
    "_rev": ".....", 
    "name": "first", 
    "something": "blue", 
    "child": "2" 
} 

{ 
    "_id": "2", 
    "_rev": ".....", 
    "name": "second", 
    "something": "green", 
    "child": "3" 
    "parent" : "1" 
    } 

{ 
    "_id": "3", 
    "_rev": ".....", 
    "name": "second", 
    "something": "red", 
    "parent" : "2"; 
} 

मैं एक दृश्य है, जो सभी रंग देता है लेखन कोई समस्या नहीं है

function(doc) { 
     if (doc.something) { 
      emit(doc.something,doc._id);  
    } 
} 

लेकिन क्या होगा अगर मैं सभी सन्तान जानना चाहता हूँ (नहीं बच्चे, क्षमा करें मेरी गलती) _id = 1 ("कुछ": "नीला") के साथ तत्व के लिए? मेरा प्रोग्रामिंग अनुभव मुझे बताता है कि मुझे रिकर्सन का उपयोग करना चाहिए, लेकिन मुझे नहीं पता कि कैसे। व्यू फ़ंक्शन से मैं एक और दृश्य फ़ंक्शन कैसे कॉल कर सकता हूं?

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

संपादित करें: उदाहरण के लिए: मैं सिर्फ पता _ id = 1 और परिणाम की तरह कुछ किया जाना चाहिए [_ id = 2, _ id = 3], क्योंकि 2 1 और 3 का एक बच्चा है का एक बच्चा है

function (doc) { 
    if (doc.parent) { 
     emit(doc.parent, { "_id": doc._id }); 
    } 
} 

("बच्चा" संपत्ति आप दस्तावेज़ में है: 2.

Answer 1

यदि संभव हो तो दस्तावेज़ पदानुक्रम को इस तरह परिभाषित न करें - आप रास्ते के प्रत्येक चरण कोचडबी से लड़ेंगे।

आप वास्तव में पदानुक्रम को देखने में नहीं चल सकते हैं। दृश्य प्रत्येक दस्तावेज़ को स्वतंत्र रूप से दूसरों (मानचित्र) पर स्थानांतरित करने और उनके द्वारा कुछ कुल मूल्य उत्पन्न करने के लिए हैं (कम)।

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

आप इस डेटा संरचना (माता पिता/बच्चे के लिए लिंक) रखने की जरूरत है, तो मैं सुझाव है कि आप CouchDB के बाहर से संरचना को इकट्ठा मिलती है: मूल दस्तावेज़, आदि प्राप्त अपने बच्चों मिलता है, अपने बच्चों को पाने के लिए,

function(doc) { 
    for (var i in doc.path) { 
     emit([doc.path[i], doc.path], doc) 
    } 
} 

:

{ 
    "_id": "1", 
    "name": "first", 
    "something": "blue", 
    "path": [1] 
} 

{ 
    "_id": "2", 
    "name": "second", 
    "something": "green", 
    "path": [1,2] 
    } 

{ 
    "_id": "3", 
    "name": "second", 
    "something": "red", 
    "path": [1,2,3] 
} 

फिर आप एक दस्तावेज़ के वंशजों प्राप्त करने के लिए इस दृश्य का उपयोग कर सकते हैं:

हालांकि, CouchDB में एक पेड़ के भंडारण की पसंदीदा तरीका प्रत्येक नोड के लिए याद यह पेड़ में पथ है

_id 1 के वंशज प्राप्त करने के लिए आप इस क्वेरी चला सकते हैं:

http://c.com/db/_design/colors/_view/descendants?startkey=[1]&endkey=[1,{}] 

, एक पूर्ण पथ का अपना कमियां भंडारण भी किया गया है, हालांकि। मेरा सुझाव है कि आप यह CouchDB wiki page on trees देखें। इसके लिए स्रोत this blog post by Paul Bonser है।

Answer 2

उदाहरण आप ऊपर है, एक दस्तावेज़ आईडी के लिए बच्चों के सभी पाने के लिए, अपने नक्शे समारोह कुछ इस तरह दिखेगा 2 भी आवश्यक नहीं है।)

अपने उदाहरण डेटा को देखते हुए इसे दो बार फेंकना होगा:

[ "1", { "_id": "2" } ] 
[ "2", { "_id": "3" } ] 

एक एकल अभिभावक के लिए बच्चे आईडी पाने के लिए आपको तो जैसे दृश्य को देखने के चाहते हैं:

http://.../db/_design/viewName/_view/childfunc?key="2" 

पूर्ण दस्तावेज प्राप्त करने के लिए , क्वेरी स्ट्रिंग में include_docs पैरामीटर जोड़ें। ,

function (doc) { 
    emit([ doc._id, "" ], { "_id": doc.id }); 
    if (doc.parent) { 
     emit([ doc.parent, doc._id ], { "_id": doc.id }) 
    } 
} 

इस समारोह में दो बार फेंकना कर सकते हैं तो आप निम्नलिखित के साथ अंत:

आप एक ही समय में माता-पिता और बच्चे प्राप्त करना चाहते हैं, अपने नक्शे समारोह केवल एक छोटे से अलग है

[ [ "1", "" ], { "_id": "1" } ] 
[ [ "1", "2" ], { "_id": "2" } ] 
[ [ "2", "" ], { "_id": "2" } ] 
[ [ "2", "3" ], { "_id": "3" } ] 
[ [ "3", "" ], { "_id": "3" } ] 

सॉर्टिंग संयोजन के लिए धन्यवाद, माता-पिता पहले खत्म होते हैं (क्योंकि उनका दूसरा मुख्य तत्व "" है) और बच्चे इसके बाद खत्म हो जाते हैं। आपको दूसरे कुंजी तत्व के रूप में बच्चे _id का उपयोग करने की आवश्यकता नहीं है, आप जो भी प्राकृतिक सॉर्टिंग संपत्ति का सबसे अधिक उपयोग कर सकते हैं उसका उपयोग कर सकते हैं।

function (key, vals) { 
    var children = []; 
    for (var docId in vals) { 
     if (key[1] !== "") { 
      children.push(docId); 
     } 
    } 
    return children; 
} 

कि समारोह: (। निर्माण तिथि, नाम, शीर्षक, जो कुछ भी)

आप "बच्चा" संपत्ति नहीं था, तो आप कर सकते हैं एक माता पिता के बच्चों के सभी प्राप्त करने के लिए समारोह को कम यह देखने के लिए देखता है कि कुंजी का बच्चा हिस्सा खाली नहीं है, और यदि ऐसा है तो यह दस्तावेज़ आईडी को सरणी में धक्का देता है।यह इस तरह के सभी मूल्यों पर लूप करता है, और पूरा होने पर सरणी देता है।