कैसे आप Mongoid में संबंधों पर आधारित chainable स्कोप की स्थापना

Question

समस्या तय ... पता चला था एक सक्रिय रिकॉर्ड विधि है कि मिल गया लिखा से अधिक है, अब सब कुछ उम्मीद के रूप में काम करता है

मैं स्थापित करने के लिए कोशिश कर रहा हूँ कर स्कोप तो मैं

class Competitor < Competitor 
    belongs_to :type 
    has_and_belongs_to_many :events 
    scope :at_event, ->(event) {where(:event_ids.in => event.competitor_ids)} 
    scope :of_type, ->(type) where(:type_id => type.id)     
end 

की तरह एक फोन है कि

Competitor.of_type(type).at_event(event) 

कि प्रकार है कि घटना मेरे मॉडल में भाग लिया के सभी प्रतियोगियों वापस आ जाएगी तरह लग रहा है कुछ लग रहा है कर सकते हैं

निम्नलिखित काम करता है (mongoid मापदंड वापसी)

Competitor.of_type(type) 
Competitor.at_event(event) 

लेकिन जब मैं उन्हें श्रृंखला, यह कुछ है कि इस तरह दिखता है बाहर प्रिंट:

#<Competitor:0x00000109e2b210> 
#<Competitor:0x00000109e2ab08> 
-------=-=------------------------------------ 
=> #<Mongoid::Criteria 
selector: {}, 
options: {}, 
class: Competitor, 
embedded: false> 

प्रतियोगी से प्रत्येक के लिए एक प्रतियोगी प्रवेश नहीं है। of_type (प्रकार) (पहला जंजीर मानदंड) और यदि मैं चलाता हूं। क्वेरी पर गणना, मुझे डेटाबेस में प्रतिस्पर्धा करने वालों की कुल संख्या मिलती है।

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

मैं परिणाम मैं चाहता था वापस जाने के लिए निम्नलिखित प्राप्त करने में सक्षम था:

where(:id.in => event.competitor_ids).where(:type_id => type.id) 

लेकिन अगर क्वेरी के किसी भी हिस्से में एक अलग विधि या गुंजाइश में विभाजित है यह विफल रहता है और परिणाम मैं ऊपर से पता चला है प्रदान करता है।

Answer 1

स्कोप

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

नामित स्कॉप्स को स्कोप मैक्रो का उपयोग करके कक्षा स्तर पर परिभाषित किया गया है और एक अच्छा डीएसएल में परिणाम सेट बनाने के लिए जंजीर किया जा सकता है।

class Person 
    include Mongoid::Document 
    field :occupation, type: String 
    field :age, type: Integer 

    scope :rock_n_rolla, where(occupation: "Rockstar") 
    scope :washed_up, where(:age.gt => 30) 
    scope :over, ->(limit) { where(:age.gt => limit) } 
end 

# Find all the rockstars. 
Person.rock_n_rolla 

# Find all rockstars that should probably quit. 
Person.washed_up.rock_n_rolla 

# Find a criteria with Keith Richards in it. 
Person.rock_n_rolla.over(60) 

ध्यान दें कि परिभाषाओं वर्ग लोड करते समय मूल्यांकन किया जाता है। रनटाइम पर मूल्यांकन के लिए आप proc या lambda का उपयोग करके परिभाषित करना सुनिश्चित करना चाहते हैं। निम्नलिखित उदाहरण में पहली तारीख को वर्ग लोड की तिथि के रूप में सेट किया गया है, जहां दूसरा दायरा उस समय की तारीख को सेट करता है, जिसे दायरा कहा जाता है।

scope :current, where(:start_date.lte => Date.today) 
scope :current, -> { where(:start_date.lte => Date.today) } 

वर्ग तरीकों

जो लोग एक डेटा मैपर शैली वाक्य रचना पसंद करते हैं के लिए, वर्ग तरीकों कि मापदंड लौट chainable स्कोप के रूप में रूप में अच्छी तरह से इलाज किया जा सकता है।

class Person 
    include Mongoid::Document 
    field :occupation, type: String 
    field :age, type: Integer 

    class << self 

    def rock_n_rolla 
     where(occupation: "Rockstar") 
    end 

    def washed_up 
     where(:age.gt => 30) 
    end 

    def over(limit) 
     where(:age.gt => limit) 
    end 
    end 
end 

# Find all the rockstars. 
Person.rock_n_rolla 

# Find all rockstars that should probably quit. 
Person.washed_up.rock_n_rolla 

# Find a criteria with Keith Richards in it. 
Person.rock_n_rolla.over(60) 

नाम स्कोप और वर्ग के तरीकों की है जो मापदंड एक साथ श्रृंखलित जा सकता है - कि Mongoid के शक्तिशाली मापदंड एपीआई की खासियत है।

class Person 
    include Mongoid::Document 
    field :occupation, type: String 
    field :age, type: Integer 

    scope :washed_up, where(:age.gt => 30) 
    scope :over, ->(limit) { where(:age.gt => limit) } 

    def self.rock_n_rolla 
    where(occupation: "Rockstar") 
    end 
end 

# Same queries apply here as well. 
Person.rock_n_rolla 
Person.washed_up.rock_n_rolla 
Person.rock_n_rolla.over(60)