ActiveRecord क्वेरी यूनियन

Question 1

मैंने रेल के क्वेरी इंटरफ़ेस पर रूबी के साथ कुछ जटिल प्रश्न (कम से कम मेरे लिए) लिखे हैं:

watched_news_posts = Post.joins(:news => :watched).where(:watched => {:user_id => id})
watched_topic_posts = Post.joins(:post_topic_relationships => {:topic => :watched}).where(:watched => {:user_id => id})

ये दोनों ही प्रश्न अपने आप ठीक होते हैं। दोनों पोस्ट ऑब्जेक्ट वापस करते हैं। मैं इन पोस्ट्स को एक सिंगल एक्टिवेशन में जोड़ना चाहूंगा। चूंकि कुछ बिंदु पर सैकड़ों हजारों पद हो सकते हैं, इसलिए इसे डेटाबेस स्तर पर करने की आवश्यकता है। यदि यह एक MySQL क्वेरी होती, तो मैं बस UNIONऑपरेटर को उपयोगकर्ता कर सकता था । क्या किसी को पता है कि क्या मैं RoR के क्वेरी इंटरफेस के साथ कुछ ऐसा कर सकता हूं?

Question 2

यहाँ एक छोटा सा मॉड्यूल है जो मैंने लिखा है कि आप कई स्कोपों को UNION करने की अनुमति देता है। यह ActiveRecord :: Relation के उदाहरण के रूप में भी परिणाम देता है।

module ActiveRecord::UnionScope
  def self.included(base)
    base.send :extend, ClassMethods
  end

  module ClassMethods
    def union_scope(*scopes)
      id_column = "#{table_name}.id"
      sub_query = scopes.map { |s| s.select(id_column).to_sql }.join(" UNION ")
      where "#{id_column} IN (#{sub_query})"
    end
  end
end

यहां बताइए गिस्ट: https://gist.github.com/tlowrimore/5162327

संपादित करें:

जैसा कि अनुरोध किया गया है, यहां एक उदाहरण है कि यूनियनस्कोप कैसे काम करता है:

class Property < ActiveRecord::Base
  include ActiveRecord::UnionScope

  # some silly, contrived scopes
  scope :active_nearby,     -> { where(active: true).where('distance <= 25') }
  scope :inactive_distant,  -> { where(active: false).where('distance >= 200') }

  # A union of the aforementioned scopes
  scope :active_near_and_inactive_distant, -> { union_scope(active_nearby, inactive_distant) }
end

Question 3

मुझे इस समस्या का भी सामना करना पड़ा है, और अब मेरी जाने की रणनीति एसक्यूएल (हाथ से या to_sqlमौजूदा गुंजाइश पर) का उत्पादन करना है और फिर इसे fromक्लॉज में चिपका देना है। मैं यह स्वीकार नहीं कर सकता कि यह आपके स्वीकृत तरीके से अधिक कुशल है, लेकिन यह आंखों पर अपेक्षाकृत आसान है और आपको एक सामान्य एआरएल ऑब्जेक्ट वापस देता है।

watched_news_posts = Post.joins(:news => :watched).where(:watched => {:user_id => id})
watched_topic_posts = Post.joins(:post_topic_relationships => {:topic => :watched}).where(:watched => {:user_id => id})

Post.from("(#{watched_news_posts.to_sql} UNION #{watched_topic_posts.to_sql}) AS posts")

आप इसे दो अलग-अलग मॉडलों के साथ भी कर सकते हैं, लेकिन आपको यह सुनिश्चित करने की आवश्यकता है कि वे दोनों "समान दिखें" जो कि UNION के अंदर हैं - आप selectदोनों प्रश्नों का उपयोग यह सुनिश्चित करने के लिए कर सकते हैं कि वे एक ही कॉलम का उत्पादन करेंगे।

topics = Topic.select('user_id AS author_id, description AS body, created_at')
comments = Comment.select('author_id, body, created_at')

Comment.from("(#{comments.to_sql} UNION #{topics.to_sql}) AS comments")

Question 4

ओलिव्स के जवाब के आधार पर, मैं इस समस्या का एक और समाधान लेकर आया। यह एक हैक की तरह थोड़ा सा महसूस करता है, लेकिन यह एक उदाहरण देता है ActiveRelation, जो कि मैं पहले स्थान पर था।

Post.where('posts.id IN 
      (
        SELECT post_topic_relationships.post_id FROM post_topic_relationships
          INNER JOIN "watched" ON "watched"."watched_item_id" = "post_topic_relationships"."topic_id" AND "watched"."watched_item_type" = "Topic" WHERE "watched"."user_id" = ?
      )
      OR posts.id IN
      (
        SELECT "posts"."id" FROM "posts" INNER JOIN "news" ON "news"."id" = "posts"."news_id" 
        INNER JOIN "watched" ON "watched"."watched_item_id" = "news"."id" AND "watched"."watched_item_type" = "News" WHERE "watched"."user_id" = ?
      )', id, id)

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

Question 5

आप ब्रायन हेम्पेल के सक्रिय_रेकोर्ड_यूनियन मणि का भी उपयोग कर सकते हैं जो स्कोप के लिए ActiveRecordएक unionविधि के साथ फैली हुई है ।

आपकी क्वेरी इस तरह होगी:

Post.joins(:news => :watched).
  where(:watched => {:user_id => id}).
  union(Post.joins(:post_topic_relationships => {:topic => :watched}
    .where(:watched => {:user_id => id}))

उम्मीद है कि यह अंततः ActiveRecordकिसी दिन में विलय हो जाएगा।

Question 6

कैसा रहेगा...

def union(scope1, scope2)
  ids = scope1.pluck(:id) + scope2.pluck(:id)
  where(id: ids.uniq)
end

Question 7

क्या आप एक UNION के बजाय OR का उपयोग कर सकते हैं?

तब आप कुछ ऐसा कर सकते थे:

Post.joins(:news => :watched, :post_topic_relationships => {:topic => :watched})
.where("watched.user_id = :id OR topic_watched.user_id = :id", :id => id)

(चूंकि आप दो बार देखे गए तालिका में शामिल होते हैं, मुझे यह भी निश्चित नहीं है कि क्वेरी के लिए तालिकाओं के नाम क्या होंगे)

चूंकि बहुत सारे जोड़ हैं, इसलिए यह डेटाबेस पर काफी भारी हो सकता है, लेकिन यह अनुकूलित करने में सक्षम हो सकता है।

Question 8

यकीनन, यह पठनीयता में सुधार करता है, लेकिन जरूरी नहीं कि प्रदर्शन:

def my_posts
  Post.where <<-SQL, self.id, self.id
    posts.id IN 
    (SELECT post_topic_relationships.post_id FROM post_topic_relationships
    INNER JOIN watched ON watched.watched_item_id = post_topic_relationships.topic_id 
    AND watched.watched_item_type = "Topic" 
    AND watched.user_id = ?
    UNION
    SELECT posts.id FROM posts 
    INNER JOIN news ON news.id = posts.news_id 
    INNER JOIN watched ON watched.watched_item_id = news.id 
    AND watched.watched_item_type = "News" 
    AND watched.user_id = ?)
  SQL
end

यह विधि एक ActiveRecord :: Relation देता है, इसलिए आप इसे इस तरह कह सकते हैं:

my_posts.order("watched_item_type, post.id DESC")

Question 9

एक सक्रिय_क्रिक_नियन रत्न है। सहायक हो सकता है

https://github.com/brianhempel/active_record_union

ActiveRecordUnion के साथ, हम कर सकते हैं:

वर्तमान उपयोगकर्ता (ड्राफ्ट) पोस्ट और सभी प्रकाशित पोस्ट जो किसी भी current_user.posts.union(Post.published) निम्न SQL के बराबर है:

SELECT "posts".* FROM (
  SELECT "posts".* FROM "posts"  WHERE "posts"."user_id" = 1
  UNION
  SELECT "posts".* FROM "posts"  WHERE (published_at < '2014-07-19 16:04:21.918366')
) posts

Question 10

मुझे आपके द्वारा आवश्यक दो प्रश्नों को चलाने और वापस आने वाले अभिलेखों के संयोजन को जोड़ना होगा:

@posts = watched_news_posts + watched_topics_posts

या, कम से कम इसका परीक्षण करें। क्या आपको लगता है कि माणिक में सरणी संयोजन बहुत धीमी गति से होगा? समस्या के आस-पास होने के लिए सुझाए गए प्रश्नों को देखते हुए, मुझे विश्वास नहीं हो रहा है कि प्रदर्शन के अंतर में यह महत्वपूर्ण होगा।

Question 11

इसी तरह के एक मामले में मैंने दो सरणियों का सारांश दिया और उपयोग किया Kaminari:paginate_array()। बहुत अच्छा और काम कर समाधान। मैं उपयोग करने में असमर्थ था where(), क्योंकि मुझे order()एक ही टेबल पर अलग-अलग दो परिणामों की राशि चाहिए ।

Question 12

कम समस्याओं और आसान का पालन करें:

    def union_scope(*scopes)
      scopes[1..-1].inject(where(id: scopes.first)) { |all, scope| all.or(where(id: scope)) }
    end

तो अंत में:

union_scope(watched_news_posts, watched_topic_posts)

Question 13

इलियट नेल्सन ने अच्छा जवाब दिया, उस मामले को छोड़कर जहां कुछ संबंध खाली हैं। मैं ऐसा कुछ करूंगा:

def union_2_relations(relation1,relation2)
sql = ""
if relation1.any? && relation2.any?
  sql = "(#{relation1.to_sql}) UNION (#{relation2.to_sql}) as #{relation1.klass.table_name}"
elsif relation1.any?
  sql = relation1.to_sql
elsif relation2.any?
  sql = relation2.to_sql
end
relation1.klass.from(sql)

समाप्त

Question 14

Heres कैसे मैं अपने स्वयं के रूबी पर रेल अनुप्रयोग का उपयोग कर SQL प्रश्नों में शामिल हो गया।

आप अपने स्वयं के कोड पर प्रेरणा के रूप में नीचे का उपयोग कर सकते हैं।

class Preference < ApplicationRecord
  scope :for, ->(object) { where(preferenceable: object) }
end

नीचे UNION है जहाँ मैं एक साथ scopes में शामिल हुआ।

  def zone_preferences
    zone = Zone.find params[:zone_id]
    zone_sql = Preference.for(zone).to_sql
    region_sql = Preference.for(zone.region).to_sql
    operator_sql = Preference.for(Operator.current).to_sql

    Preference.from("(#{zone_sql} UNION #{region_sql} UNION #{operator_sql}) AS preferences")
  end