सशर्त जोड़ने के लिए जहां रेलों में खंड

Question

मैं रेल की नौसिखिया हूं और रेल के साथ एक टेबल पर एक खोज करने की कोशिश कर रहा हूं, और मैं बस ऐसा करने के लिए अपने एसक्यूएल ज्ञान का उपयोग कर रहा हूं। लेकिन यह सिर्फ रेल या रूबी की तरह नहीं लगता है ...

क्या मैं नीचे क्या कर रहा हूं करने का कोई बेहतर तरीका है? (मूल रूप से, केवल तारीख तर्क पारित SQL के अगर वे भर रहे हैं)

def search(begin_date=nil, end_date=nil) 

    subject = " and created_at " 

    if !(begin_date.nil? || end_date.nil?) 
     where_part = subject + "BETWEEN :begin_date AND :end_date" 
    else if (begin_date.nil? && end_date.nil?) 
     where_part = "" 
    else if(begin_date.nil?) 
     where_part = subject + " <= :end_date" 
    else if (end_date.nil?) 
     where_part = subject + " >= :begin_date" 
    end 
    end 
    end 
    end 

    User.joins(places: {containers: {label: :user}}).where("users.id= :user_id "+where_part, user_id: self.id, begin_date:begin_date, end_date:end_date).group(...).select(...) 
end 

संपादित

user.rb

has_many :containers 
has_many :user_places 
has_many :places, through: :user_places 
has_many :labels 

place.rb

has_many :containers 
has_many :user_places 
has_many :users, through: :user_places 

कंटेनर। आरबी

belongs_to :label 
belongs_to :place 
belongs_to :user 

label.rb

belongs_to :user 
has_many :containers 

असल में, मैं स्थान प्रति, किसी दिए गए उपयोगकर्ता के लेबल के भीतर या एक सीधा संबंध के साथ कंटेनरों की संख्या की गिनती मिलता है, और यह फिल्टर करने के लिए सक्षम होना चाहते हैं करना चाहते हैं शुरुआत और समाप्ति तिथियों से।

इनमें से कोई भी तारीख शून्य हो सकती है, और इसलिए मुझे इसे "क्वेरी" में संबोधित करने की आवश्यकता होगी।

मेरा सवाल है: मैं रेलवे तरीके कैसे कर सकता हूं? मैंने http://guides.rubyonrails.org/active_record_querying.html पर एक नज़र डाली और शायद मैं कहीं भी छोड़कर कमांड का उपयोग कर सकता हूं ... लेकिन यह रिलेशनशिप मॉडल सिर्फ ActiveRecord के साथ ऐसा करने के लिए थोड़ा जटिल लगता है ... मैं कैसे कर सकता हूं, मुझे सच में लगता है कि मुझे ActiveRecord का उपयोग करना चाहिए, लेकिन कैसे?

धन्यवाद

Answer 1

तो आप अपने आधार क्वेरी निर्माण कर सकते हैं आप एक सवाल के कई where कॉल आवेदन कर सकते हैं:

query = User.joins(...) 
      .group(...) 
      .select(...) 
      .where('users.id = :user_id', :user_id => self.id) 

और फिर अपने दिनांक अंतराल के आधार पर एक और where कॉल जोड़ें:

if(begin_date && end_date) 
    query = query.where(:created_at => begin_date .. end_date) 
    # or where('created_at between :begin_date and :end_date', :begin_date => begin_date, :end_date => end_date) 
elsif(begin_date) 
    query = query.where('created_at >= :begin_date', :begin_date => begin_date) 
elsif(end_date) 
    query = query.where('created_at <= :end_date', :end_date => end_date) 
end 

प्रत्येक where कॉल आपके समग्र WHERE क्लॉज का उपयोग करके एक और टुकड़ा जोड़ता है और ऐसा कुछ करता है:

q = M.where(a).where(b).where(c) 

WHERE a AND b AND c कहने जैसा ही है।

Answer 2

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

Link explaining how to join tables with active record